[ tor-browser ].git.dasho

commit 785573dcd5371f7a9278b58d4106fc14d1e38951
parent 0739687a63d51e63c03b3c8670832d7a34568879
Author: Henri Sivonen <hsivonen@hsivonen.fi>
Date:   Thu, 13 Nov 2025 07:28:23 +0000

Bug 1986265 - Re-vendor application-services to use ICU4X instead of unicode-normalization and unicase. r=sylvestre,supply-chain-reviewers,adw,mvanstraten

Differential Revision: https://phabricator.services.mozilla.com/D271627

Diffstat:
M .cargo/config.toml.in  | 4 ++--
M Cargo.lock  | 129 +++++++++++++++++++++++++++++++++++++------------------------------------------
M Cargo.toml  | 33 +++++++++++++++------------------
D build/rust/itertools/Cargo.toml  | 17 -----------------
D build/rust/itertools/lib.rs  | 5 -----
M python/mozbuild/mozbuild/vendor/vendor_rust.py  | 4 +---
M supply-chain/imports.lock  | 35 ++++++++++++++++++++++++++++-------
M third_party/rust/error-support/.cargo-checksum.json  | 4 ++--
M third_party/rust/error-support/src/error_tracing.rs  | 27 ++++++++++++++++++++++++++-
A third_party/rust/icu_casemap/.cargo-checksum.json  | 2 ++
A third_party/rust/icu_casemap/Cargo.lock  | 903 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/Cargo.toml  | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/LICENSE  | 46 ++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/README.md  | 34 ++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/benches/casemap.rs  | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/benches/data/Iliad.txt  | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/casemapper.rs  | 806 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/closer.rs  | 287 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/greek_to_me/data.rs  | 24 ++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/greek_to_me/mod.rs  | 321 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/internals.rs  | 865 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/lib.rs  | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/provider/data.rs  | 527 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/provider/exception_helpers.rs  | 279 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/provider/exceptions.rs  | 566 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/provider/exceptions_builder.rs  | 290 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/provider/mod.rs  | 202 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/provider/unfold.rs  | 105 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/set.rs  | 36 ++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/src/titlecase.rs  | 486 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/tests/conversions.rs  | 409 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap/tests/gen_greek_to_me.rs  | 202 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap_data/.cargo-checksum.json  | 2 ++
A third_party/rust/icu_casemap_data/Cargo.lock  | 7 +++++++
A third_party/rust/icu_casemap_data/Cargo.toml  | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap_data/LICENSE  | 46 ++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap_data/README.md  | 14 ++++++++++++++
A third_party/rust/icu_casemap_data/build.rs  | 11 +++++++++++
A third_party/rust/icu_casemap_data/data/case_map_unfold_v1.rs.data  | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap_data/data/case_map_v1.rs.data  | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap_data/data/mod.rs  | 36 ++++++++++++++++++++++++++++++++++++
A third_party/rust/icu_casemap_data/src/lib.rs  | 17 +++++++++++++++++
M third_party/rust/nss/.cargo-checksum.json  | 4 ++--
M third_party/rust/nss/src/pk11/sym_key.rs  | 19 +++++++------------
M third_party/rust/nss_sys/.cargo-checksum.json  | 4 ++--
M third_party/rust/nss_sys/src/bindings/pk11pub.rs  | 5 -----
M third_party/rust/prost-derive/.cargo-checksum.json  | 4 ++--
A third_party/rust/prost-derive/Cargo.lock  | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M third_party/rust/prost-derive/Cargo.toml  | 24 +++++++++++++++---------
M third_party/rust/prost-derive/src/field/group.rs  | 9 +++++----
M third_party/rust/prost-derive/src/field/message.rs  | 12 +++++-------
M third_party/rust/prost-derive/src/field/mod.rs  | 8 ++------
M third_party/rust/prost-derive/src/field/oneof.rs  | 12 +++++-------
M third_party/rust/prost-derive/src/field/scalar.rs  | 12 ++++++------
M third_party/rust/prost-derive/src/lib.rs  | 230 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------
M third_party/rust/prost/.cargo-checksum.json  | 4 ++--
A third_party/rust/prost/Cargo.lock  | 787 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M third_party/rust/prost/Cargo.toml  | 49 +++++++++++++++++++++++++------------------------
D third_party/rust/prost/FUZZING.md  | 27 ---------------------------
D third_party/rust/prost/KANI.md  | 69 ---------------------------------------------------------------------
M third_party/rust/prost/README.md  | 29 ++++++++++++++++++-----------
M third_party/rust/prost/benches/varint.rs  | 2 +-
D third_party/rust/prost/clippy.toml  | 1 -
D third_party/rust/prost/flake.lock  | 43 -------------------------------------------
D third_party/rust/prost/flake.nix  | 20 --------------------
D third_party/rust/prost/prepare-release.sh  | 47 -----------------------------------------------
D third_party/rust/prost/publish-release.sh  | 33 ---------------------------------
M third_party/rust/prost/src/encoding.rs  | 494 +++++++++++--------------------------------------------------------------------
A third_party/rust/prost/src/encoding/length_delimiter.rs  | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/prost/src/encoding/varint.rs  | 274 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A third_party/rust/prost/src/encoding/wire_type.rs  | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
M third_party/rust/prost/src/error.rs  | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
M third_party/rust/prost/src/lib.rs  | 67 +++++++------------------------------------------------------------
M third_party/rust/prost/src/message.rs  | 51 +++++++++++++++++++--------------------------------
M third_party/rust/prost/src/name.rs  | 18 ++++++++++++------
M third_party/rust/prost/src/types.rs  | 374 +++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------
M third_party/rust/remote_settings/.cargo-checksum.json  | 4 ++--
M third_party/rust/remote_settings/dumps/main/search-config-v2.json  | 62 ++++++++++++++++++++++++++++++++++++++++++--------------------
M third_party/rust/remote_settings/dumps/main/search-telemetry-v2.json  | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
M third_party/rust/remote_settings/dumps/main/summarizer-models-config.json  | 23 ++++++++++++-----------
M third_party/rust/suggest/.cargo-checksum.json  | 4 ++--
M third_party/rust/suggest/Cargo.toml  | 9 +++++++--
M third_party/rust/suggest/src/util.rs  | 31 +++++++++++++++++++++++++------
D third_party/rust/tinyvec/.cargo-checksum.json  | 2 --
D third_party/rust/tinyvec/CHANGELOG.md  | 104 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/Cargo.lock  | 647 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/Cargo.toml  | 158 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/LICENSE-APACHE.md  | 202 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/LICENSE-MIT.md  | 5 -----
D third_party/rust/tinyvec/LICENSE-ZLIB.md  | 11 -----------
D third_party/rust/tinyvec/README.md  | 34 ----------------------------------
D third_party/rust/tinyvec/benches/macros.rs  | 52 ----------------------------------------------------
D third_party/rust/tinyvec/benches/smallvec.rs  | 503 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/debug_metadata/README.md  | 111 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/debug_metadata/tinyvec.natvis  | 25 -------------------------
D third_party/rust/tinyvec/rustfmt.toml  | 14 --------------
D third_party/rust/tinyvec/src/array.rs  | 54 ------------------------------------------------------
D third_party/rust/tinyvec/src/array/const_generic_impl.rs  | 23 -----------------------
D third_party/rust/tinyvec/src/array/generated_impl.rs  | 9616 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/src/array/generic_array_impl.rs  | 26 --------------------------
D third_party/rust/tinyvec/src/arrayvec.rs  | 2079 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/src/arrayvec_drain.rs  | 99 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/src/lib.rs  | 112 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/src/slicevec.rs  | 1083 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/src/tinyvec.rs  | 1910 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/tests/arrayvec.rs  | 500 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/tests/debugger_visualizer.rs  | 91 -------------------------------------------------------------------------------
D third_party/rust/tinyvec/tests/tinyvec.rs  | 501 -------------------------------------------------------------------------------
D third_party/rust/tinyvec_macros/.cargo-checksum.json  | 2 --
D third_party/rust/tinyvec_macros/Cargo.toml  | 19 -------------------
D third_party/rust/tinyvec_macros/LICENSE-APACHE.md  | 202 -------------------------------------------------------------------------------
D third_party/rust/tinyvec_macros/LICENSE-MIT.md  | 21 ---------------------
D third_party/rust/tinyvec_macros/LICENSE-ZLIB.md  | 20 --------------------
D third_party/rust/tinyvec_macros/src/lib.rs  | 25 -------------------------
D third_party/rust/unicode-normalization/.cargo-checksum.json  | 2 --
D third_party/rust/unicode-normalization/COPYRIGHT  | 7 -------
D third_party/rust/unicode-normalization/Cargo.toml  | 66 ------------------------------------------------------------------
D third_party/rust/unicode-normalization/LICENSE-APACHE  | 201 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/LICENSE-MIT  | 25 -------------------------
D third_party/rust/unicode-normalization/README.md  | 39 ---------------------------------------
D third_party/rust/unicode-normalization/benches/bench.rs  | 127 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/scripts/unicode.py  | 617 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/__test_api.rs  | 18 ------------------
D third_party/rust/unicode-normalization/src/decompose.rs  | 173 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/lib.rs  | 227 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/lookups.rs  | 138 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/normalize.rs  | 224 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/perfect_hash.rs  | 50 --------------------------------------------------
D third_party/rust/unicode-normalization/src/quick_check.rs  | 190 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/recompose.rs  | 169 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/replace.rs  | 66 ------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/stream_safe.rs  | 174 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/tables.rs  | 22803 -------------------------------------------------------------------------------
D third_party/rust/unicode-normalization/src/test.rs  | 130 -------------------------------------------------------------------------------
M third_party/rust/viaduct/.cargo-checksum.json  | 4 ++--
M third_party/rust/viaduct/Cargo.toml  | 2 +-
M toolkit/components/gecko-trace/Cargo.toml  | 2 +-
M toolkit/content/license.html  | 2 ++

138 files changed, 9334 insertions(+), 44927 deletions(-)
diff --git a/.cargo/config.toml.in b/.cargo/config.toml.in
@@ -80,9 +80,9 @@ git = "https://github.com/martinthomson/ohttp.git"
 rev = "bf6a983845cc0b540effb3a615e92d914dfcfd0b"
 replace-with = "vendored-sources"
 
-[source."git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d"]
+[source."git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70"]
 git = "https://github.com/mozilla/application-services"
-rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d"
+rev = "799ae231ba91f5b6634672a2737cc9efdf997b70"
 replace-with = "vendored-sources"
 
 [source."git+https://github.com/mozilla/audioipc?rev=82fe7fa7e3aaa35468137239a0e4c2f867457214"]
diff --git a/Cargo.lock b/Cargo.lock
@@ -466,7 +466,7 @@ dependencies = [
  "bitflags 2.9.0",
  "cexpr",
  "clang-sys",
- "itertools 0.14.0",
+ "itertools",
  "proc-macro2",
  "quote",
  "regex",
@@ -972,7 +972,7 @@ dependencies = [
 [[package]]
 name = "context_id"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "chrono",
  "error-support",
@@ -1897,7 +1897,7 @@ dependencies = [
 [[package]]
 name = "error-support"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "env_logger",
  "error-support-macros",
@@ -1912,7 +1912,7 @@ dependencies = [
 [[package]]
 name = "error-support-macros"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2007,7 +2007,7 @@ dependencies = [
 [[package]]
 name = "filter_adult"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "base64 0.22.1",
  "error-support",
@@ -2043,7 +2043,7 @@ dependencies = [
 [[package]]
 name = "firefox-versioning"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "serde_json",
  "thiserror 2.0.12",
@@ -3180,6 +3180,29 @@ dependencies = [
 ]
 
 [[package]]
+name = "icu_casemap"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2183be5a01b948227f1a521f4e586ee69828d2eecc1d2397ce686de68233d27d"
+dependencies = [
+ "displaydoc",
+ "icu_casemap_data",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties",
+ "icu_provider",
+ "potential_utf",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_casemap_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7584067558ab4c60c95d1ac2abd1588689cb4bcd4e099507f62dae86ae8d2c0"
+
+[[package]]
 name = "icu_collections"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3411,7 +3434,7 @@ dependencies = [
 [[package]]
 name = "init_rust_components"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "nss",
  "uniffi",
@@ -3420,7 +3443,7 @@ dependencies = [
 [[package]]
 name = "interrupt-support"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "lazy_static",
  "parking_lot",
@@ -3495,13 +3518,6 @@ dependencies = [
 
 [[package]]
 name = "itertools"
-version = "0.10.999"
-dependencies = [
- "itertools 0.14.0",
-]
-
-[[package]]
-name = "itertools"
 version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
@@ -3601,7 +3617,7 @@ dependencies = [
 [[package]]
 name = "jwcrypto"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "base64 0.21.999",
  "error-support",
@@ -3933,7 +3949,7 @@ checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
 [[package]]
 name = "logins"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -4340,7 +4356,7 @@ dependencies = [
  "futures",
  "getrandom 0.2.999",
  "hex",
- "itertools 0.14.0",
+ "itertools",
  "maybe-async",
  "mls-rs-codec",
  "mls-rs-core",
@@ -4587,7 +4603,7 @@ dependencies = [
  "icu_properties",
  "idna",
  "indexmap",
- "itertools 0.14.0",
+ "itertools",
  "libc",
  "log",
  "memchr",
@@ -4982,7 +4998,7 @@ dependencies = [
 [[package]]
 name = "nss"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "base64 0.21.999",
  "error-support",
@@ -5011,12 +5027,12 @@ dependencies = [
 [[package]]
 name = "nss_build_common"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 
 [[package]]
 name = "nss_sys"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "libsqlite3-sys",
  "nss_build_common",
@@ -5289,7 +5305,7 @@ checksum = "d01a5bd0424d00070b0098dd17ebca6f961a959dead1dbcbbbc1d1cd8d3deeba"
 [[package]]
 name = "payload-support"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "serde",
  "serde_derive",
@@ -5619,9 +5635,9 @@ checksum = "74605f360ce573babfe43964cbe520294dcb081afbf8c108fc6e23036b4da2df"
 
 [[package]]
 name = "prost"
-version = "0.12.1"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4fdd22f3b9c31b53c060df4a0613a1c7f062d4115a2b984dd15b1858f7e340d"
+checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
 dependencies = [
  "bytes",
  "prost-derive",
@@ -5629,12 +5645,12 @@ dependencies = [
 
 [[package]]
 name = "prost-derive"
-version = "0.12.1"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "265baba7fabd416cf5078179f7d2cbeca4ce7a9041111900675ea7c4cb8a4c32"
+checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
 dependencies = [
  "anyhow",
- "itertools 0.10.999",
+ "itertools",
  "proc-macro2",
  "quote",
  "syn",
@@ -5813,7 +5829,7 @@ dependencies = [
 [[package]]
 name = "rc_crypto"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "base64 0.21.999",
  "error-support",
@@ -5883,7 +5899,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 [[package]]
 name = "relevancy"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "base64 0.21.999",
@@ -5907,7 +5923,7 @@ dependencies = [
 [[package]]
 name = "remote_settings"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "camino",
@@ -6199,7 +6215,7 @@ dependencies = [
 [[package]]
 name = "search"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "error-support",
  "firefox-versioning",
@@ -6525,7 +6541,7 @@ dependencies = [
 [[package]]
 name = "sql-support"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "error-support",
  "interrupt-support",
@@ -6631,7 +6647,7 @@ dependencies = [
  "gecko-profiler",
  "icu_segmenter",
  "indexmap",
- "itertools 0.14.0",
+ "itertools",
  "itoa",
  "lazy_static",
  "log",
@@ -6716,12 +6732,15 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 [[package]]
 name = "suggest"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "chrono",
  "error-support",
  "extend",
+ "icu_casemap",
+ "icu_normalizer",
+ "icu_properties",
  "interrupt-support",
  "once_cell",
  "parking_lot",
@@ -6732,8 +6751,6 @@ dependencies = [
  "serde_json",
  "sql-support",
  "thiserror 2.0.12",
- "unicase",
- "unicode-normalization",
  "uniffi",
  "url",
  "viaduct",
@@ -6769,7 +6786,7 @@ dependencies = [
 [[package]]
 name = "sync-guid"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "base64 0.21.999",
  "rand",
@@ -6780,7 +6797,7 @@ dependencies = [
 [[package]]
 name = "sync15"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "base16",
@@ -6824,7 +6841,7 @@ dependencies = [
 [[package]]
 name = "tabs"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "error-support",
@@ -6982,21 +6999,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "tinyvec"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
-[[package]]
 name = "to_shmem"
 version = "0.1.0"
 dependencies = [
@@ -7174,7 +7176,7 @@ dependencies = [
 [[package]]
 name = "tracing-support"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "parking_lot",
  "serde_json",
@@ -7240,7 +7242,7 @@ checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
 [[package]]
 name = "types"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "rusqlite 0.37.0",
  "serde",
@@ -7316,15 +7318,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
 
 [[package]]
-name = "unicode-normalization"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
 name = "unicode-width"
 version = "0.1.999"
 dependencies = [
@@ -7638,7 +7631,7 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 [[package]]
 name = "viaduct"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "async-trait",
  "error-support",
@@ -7803,7 +7796,7 @@ dependencies = [
 [[package]]
 name = "webext-storage"
 version = "0.1.0"
-source = "git+https://github.com/mozilla/application-services?rev=7ee874e18f461a83f5c8c8927039cbde3225b60d#7ee874e18f461a83f5c8c8927039cbde3225b60d"
+source = "git+https://github.com/mozilla/application-services?rev=799ae231ba91f5b6634672a2737cc9efdf997b70#799ae231ba91f5b6634672a2737cc9efdf997b70"
 dependencies = [
  "anyhow",
  "error-support",
diff --git a/Cargo.toml b/Cargo.toml
@@ -222,9 +222,6 @@ half = { path = "build/rust/half" }
 # Upgrade `rusqlite` 0.31 to 0.33.
 rusqlite = { path = "build/rust/rusqlite" }
 
-# Patch `itertools` 0.10.* to 0.14.
-itertools = { path = "build/rust/itertools" }
-
 # Overrides to allow easier use of common internal crates.
 moz_asserts = { path = "mozglue/static/rust/moz_asserts" }
 
@@ -274,21 +271,21 @@ ohttp = { git = "https://github.com/martinthomson/ohttp.git", rev = "bf6a983845c
 bhttp = { git = "https://github.com/martinthomson/ohttp.git", rev = "bf6a983845cc0b540effb3a615e92d914dfcfd0b" }
 
 # application-services overrides to make updating them all simpler.
-context_id = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-error-support = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-filter_adult = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-interrupt-support = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-relevancy = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-search = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-sql-support = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-suggest = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-sync15 = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-tabs = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-tracing-support = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-viaduct = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-webext-storage = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-logins = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
-init_rust_components = { git = "https://github.com/mozilla/application-services", rev = "7ee874e18f461a83f5c8c8927039cbde3225b60d" }
+context_id = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+error-support = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+filter_adult = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+interrupt-support = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+relevancy = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+search = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+sql-support = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+suggest = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+sync15 = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+tabs = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+tracing-support = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+viaduct = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+webext-storage = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+logins = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
+init_rust_components = { git = "https://github.com/mozilla/application-services", rev = "799ae231ba91f5b6634672a2737cc9efdf997b70" }
 # Patched version of zip 2.4.2 to allow for reading omnijars.
 zip = { path = "third_party/rust/zip" }
 
diff --git a/build/rust/itertools/Cargo.toml b/build/rust/itertools/Cargo.toml
@@ -1,17 +0,0 @@
-[package]
-name = "itertools"
-version = "0.10.999"
-edition = "2018"
-license = "MIT OR Apache-2.0"
-
-[lib]
-path = "lib.rs"
-
-[dependencies.itertools]
-version = "0.14.0"
-default-features = false
-
-[features]
-default = ["itertools/default"]
-use_alloc = ["itertools/use_alloc"]
-use_std = ["itertools/use_std"]
diff --git a/build/rust/itertools/lib.rs b/build/rust/itertools/lib.rs
@@ -1,5 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-pub use itertools::*;
diff --git a/python/mozbuild/mozbuild/vendor/vendor_rust.py b/python/mozbuild/mozbuild/vendor/vendor_rust.py
@@ -97,8 +97,7 @@ PACKAGES_WE_DONT_WANT = {
     #    "unicode-ident": "Use icu_properties instead",
     "unicode-joining-type": "Use icu_properties instead",
     "unicode-linebreak": "Use icu_segmenter instead",
-    # Exception until bug 1986265 is fixed.
-    #    "unicode-normalization": "Use icu_normalizer instead",
+    "unicode-normalization": "Use icu_normalizer instead",
     "unicode-properties": "Use icu_properties instead",
     "unicode-script": "Use icu_properties instead",
     "unicode-segmentation": "Use icu_segmenter instead",
@@ -130,7 +129,6 @@ ALLOWED_DESPITE_PREFIX = {
     "unicode-bidi",  # Out of scope for ICU4X; used with ICU4X data
     "unicode-bidi-ffi",  # FFI for previous
     "unicode-ident",  # Impractical to require icu_properties at this time
-    "unicode-normalization",  # Exception until bug 1986265 is fixed.
     "unicode-width",  # icu_properties has the raw data but not the algorithm
     "unic-langid",  # We want to migrate to icu_locale eventually
     "unic-langid-ffi",  # FFI for previous
diff --git a/supply-chain/imports.lock b/supply-chain/imports.lock
@@ -769,13 +769,6 @@ user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
-[[publisher.unicode-normalization]]
-version = "0.1.24"
-when = "2024-09-17"
-user-id = 1139
-user-login = "Manishearth"
-user-name = "Manish Goregaokar"
-
 [[publisher.unicode-width]]
 version = "0.2.0"
 when = "2024-09-19"
@@ -2011,6 +2004,34 @@ delta = "2.0.0-beta1 -> 2.0.0-beta2"
 notes = "Despite being an FFI crate, it is 100% safe code since it uses Diplomat for bindings."
 aggregated-from = "https://chromium.googlesource.com/chromium/src/+/main/third_party/rust/chromium_crates_io/supply-chain/audits.toml?format=TEXT"
 
+[[audits.google.audits.icu_casemap]]
+who = "Manish Goregaokar <manishearth@google.com>"
+criteria = "safe-to-deploy"
+version = "2.0.0-beta1"
+notes = "Safety review: One bit of unsafe DST construction from constant values. One checklisted ULE impl for a simple type wrapping RawBytesULE."
+aggregated-from = "https://chromium.googlesource.com/chromium/src/+/main/third_party/rust/chromium_crates_io/supply-chain/audits.toml?format=TEXT"
+
+[[audits.google.audits.icu_casemap]]
+who = "Manish Goregaokar <manishearth@google.com>"
+criteria = "safe-to-deploy"
+delta = "2.0.0-beta1 -> 2.0.0-beta2"
+notes = "No meaningful change to unsafe code"
+aggregated-from = "https://chromium.googlesource.com/chromium/src/+/main/third_party/rust/chromium_crates_io/supply-chain/audits.toml?format=TEXT"
+
+[[audits.google.audits.icu_casemap_data]]
+who = "Manish Goregaokar <manishearth@google.com>"
+criteria = "safe-to-deploy"
+version = "2.0.0-beta1"
+notes = "Contains codegenned unsafe only, using safe Bake impls from zerovec/zerotrie"
+aggregated-from = "https://chromium.googlesource.com/chromium/src/+/main/third_party/rust/chromium_crates_io/supply-chain/audits.toml?format=TEXT"
+
+[[audits.google.audits.icu_casemap_data]]
+who = "Manish Goregaokar <manishearth@google.com>"
+criteria = "safe-to-deploy"
+delta = "2.0.0-beta1 -> 2.0.0-beta2"
+notes = "Contains codegenned unsafe only, using safe Bake impls from zerovec/zerotrie"
+aggregated-from = "https://chromium.googlesource.com/chromium/src/+/main/third_party/rust/chromium_crates_io/supply-chain/audits.toml?format=TEXT"
+
 [[audits.google.audits.icu_collections]]
 who = "Manish Goregaokar <manishearth@google.com>"
 criteria = "safe-to-deploy"
diff --git a/third_party/rust/error-support/.cargo-checksum.json b/third_party/rust/error-support/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"379d09265c4ad36b0e8aa71fab2a82c71946a33dc00314ff0a9efd07431b8642","README.md":"d820e387ac36a98c8e554fcaba13b76eb935413b535019444f6d448240e4d07e","metrics.yaml":"d7404186be19150cfba00c7ffb4261479fd91f3b674151ed88d28d15172283b2","pings.yaml":"80e8cae15ec4b9369d92ffc2fd038931a108cfb1edcacd6f27e529a809979043","src/error_tracing.rs":"1a8738a90c5fd605f7d40a6cff2634989d06d18103157ccfe75fdb59cad8f432","src/handling.rs":"4b1183afe0716653918515299bc877a4d461fe8d2bb114a8c25f303203a35fdb","src/lib.rs":"f3860585d0cf613fe2974c5119f0738601c65c74aaba2c79311e440903dde254","src/macros.rs":"27366e0424e4d700605c34bd96295cd35fa41aed8b49f30e0b6e0c59b870fe73","src/redact.rs":"c9a4df1a87be68b15d583587bda941d4c60a1d0449e2d43ff99f3611a290a863","src/reporting.rs":"eda5580fabe633bd4fe7ac69ea8056874e8adfc093a74942294edcfbaa48824f","uniffi.toml":"af91bcd8e7b1fa3f475a5e556979ff23c57b338395e0b65abc1cb1a0ee823e23"},"package":null}
-\ No newline at end of file
+{"files":{"Cargo.toml":"379d09265c4ad36b0e8aa71fab2a82c71946a33dc00314ff0a9efd07431b8642","README.md":"d820e387ac36a98c8e554fcaba13b76eb935413b535019444f6d448240e4d07e","metrics.yaml":"d7404186be19150cfba00c7ffb4261479fd91f3b674151ed88d28d15172283b2","pings.yaml":"80e8cae15ec4b9369d92ffc2fd038931a108cfb1edcacd6f27e529a809979043","src/error_tracing.rs":"86f4d88fb9a08640924199ddae1a6a6f1267574174011caeaa1f65b6dd38157d","src/handling.rs":"4b1183afe0716653918515299bc877a4d461fe8d2bb114a8c25f303203a35fdb","src/lib.rs":"f3860585d0cf613fe2974c5119f0738601c65c74aaba2c79311e440903dde254","src/macros.rs":"27366e0424e4d700605c34bd96295cd35fa41aed8b49f30e0b6e0c59b870fe73","src/redact.rs":"c9a4df1a87be68b15d583587bda941d4c60a1d0449e2d43ff99f3611a290a863","src/reporting.rs":"eda5580fabe633bd4fe7ac69ea8056874e8adfc093a74942294edcfbaa48824f","uniffi.toml":"af91bcd8e7b1fa3f475a5e556979ff23c57b338395e0b65abc1cb1a0ee823e23"},"package":null}
+\ No newline at end of file
diff --git a/third_party/rust/error-support/src/error_tracing.rs b/third_party/rust/error-support/src/error_tracing.rs
@@ -44,7 +44,7 @@ impl BreadcrumbRingBuffer {
     }
 
     fn push(&mut self, breadcrumb: impl Into<String>) {
-        let breadcrumb = breadcrumb.into();
+        let breadcrumb = truncate_breadcrumb(breadcrumb.into());
         if self.breadcrumbs.len() < Self::MAX_ITEMS {
             self.breadcrumbs.push(breadcrumb);
         } else {
@@ -60,6 +60,19 @@ impl BreadcrumbRingBuffer {
     }
 }
 
+fn truncate_breadcrumb(breadcrumb: String) -> String {
+    // Limit breadcrumbs to 100 chars so that they fit in a Glean String list
+    // (https://mozilla.github.io/glean/book/reference/metrics/string_list.html)
+    if breadcrumb.len() <= 100 {
+        return breadcrumb;
+    }
+    let split_point = (0..=100)
+        .rev()
+        .find(|i| breadcrumb.is_char_boundary(*i))
+        .unwrap_or(0);
+    breadcrumb[0..split_point].to_string()
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -187,4 +200,16 @@ mod test {
             ]
         );
     }
+
+    #[test]
+    fn test_truncate_breadcrumb() {
+        // These don't need to be truncated
+        assert_eq!(truncate_breadcrumb("0".repeat(99)).len(), 99);
+        assert_eq!(truncate_breadcrumb("0".repeat(100)).len(), 100);
+        // This one needs truncating
+        assert_eq!(truncate_breadcrumb("0".repeat(101)).len(), 100);
+        // This one needs truncating and we need to make sure don't truncate in the middle of the
+        // fire emoji, which is multiple bytes long.
+        assert_eq!(truncate_breadcrumb("0".repeat(99) + "🔥").len(), 99);
+    }
 }
diff --git a/third_party/rust/icu_casemap/.cargo-checksum.json b/third_party/rust/icu_casemap/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"93989784910aee6755abdac3b6ab3f61c3fc0c3536639ac4e11ed0156a61100e","Cargo.toml":"74b7f8ba44057d6601c153d3d43222814d959e5e478dddf30795551b0698a872","LICENSE":"f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2","README.md":"c104cdff71458b97f14f487b4681243a09e225aa4081357e56c6b7b02cd9fd12","benches/casemap.rs":"7ab80d8e5d2c26bbd982f75f30e881dedb4cd7f00923a7f7fe44f2f57f9f4a57","benches/data/Iliad.txt":"3c95ea8f9acaec448dd702a79761ce39c0c5db5542be70c0c86689d9659f68db","src/casemapper.rs":"83622ab0774f59b93102bd1ae90024915f4da39a7954e00461ab65dc5a3a6ec9","src/closer.rs":"239c79f2972e9490643bde8fa42be332b2497406b68022b3f64cde6d14a71755","src/greek_to_me/data.rs":"6c1323893e4d6a90b323fbcc6bcd06c400a9afe999bd22d208b4c335e967d3b3","src/greek_to_me/mod.rs":"2ec4d1ff47a95a6b298684d4fff5a5cca917d6a786d19844d8f5223adec40026","src/internals.rs":"6f9db928c2e4f18db20c98db47ee244210d4e7294704ec11b25fda38a9457bfb","src/lib.rs":"2edb627e4ff3658f4125b1b24724c580894318fdc63148ca9bd5ba6b74645f1a","src/provider/data.rs":"972c6b5287e9239169dd474e555c9956a8ce8d54ebc5ce93b0d71deb11b08d35","src/provider/exception_helpers.rs":"aebcb2037f4f0d53c36d85e86069d36633e227024144d4e382ac9563ccee62b9","src/provider/exceptions.rs":"2aee8e9f4bd29782f0fffae18e646ea6001011e14ddaa5e299603b4df74e8dbf","src/provider/exceptions_builder.rs":"35dae4af44ab21d4aef1afa542814007d8cc22d4f75fd80dc08b69b54535c324","src/provider/mod.rs":"5b6d59839082a4a6e1ed419159824578fd45d3d4b7c72b3c762f93a58cc357f6","src/provider/unfold.rs":"097f179388c8d7859a011e6f0a94599b5d04bf8d2d1790011fa7ed9612a4e517","src/set.rs":"8c8a392a4cc3678b6cc0e234bff9692db8da36445e1b3fb14774720af31c58a0","src/titlecase.rs":"13ec2cfb36629be68d1401cd14e9f41360928ac8e2aca40a24f1337406b2851c","tests/conversions.rs":"d2fd4bb07e2d598bc7f87085c5af00deee975a7914a8f660c4aeb5cf359c9652","tests/gen_greek_to_me.rs":"fb986c39778fcea163f86bf3abec234acea2b8a6ba206c531bd8a75250fd3646"},"package":"2183be5a01b948227f1a521f4e586ee69828d2eecc1d2397ce686de68233d27d"}
+\ No newline at end of file
diff --git a/third_party/rust/icu_casemap/Cargo.lock b/third_party/rust/icu_casemap/Cargo.lock
@@ -0,0 +1,903 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstyle"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "bumpalo"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e578d6ec4194633722ccf9544794b71b1385c3c027efe0c55db226fc880865c"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4df4df40ec50c46000231c914968278b1eb05098cf8f1b3a518a95030e71d1c7"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+
+[[package]]
+name = "cobs"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+
+[[package]]
+name = "databake"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff6ee9e2d2afb173bcdeee45934c89ec341ab26f91c9933774fc15c2b58f83ef"
+dependencies = [
+ "databake-derive",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "databake-derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6834770958c7b84223607e49758ec0dde273c4df915e734aad50f62968a4c134"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "erased-serde"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7"
+dependencies = [
+ "serde",
+ "typeid",
+]
+
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f154ce46856750ed433c8649605bf7ed2de3bc35fd9d2a9f30cddd873c80cb08"
+
+[[package]]
+name = "icu_casemap"
+version = "2.0.1"
+dependencies = [
+ "criterion",
+ "databake",
+ "displaydoc",
+ "icu_casemap_data",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties",
+ "icu_provider",
+ "potential_utf",
+ "serde",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_casemap_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7584067558ab4c60c95d1ac2abd1588689cb4bcd4e099507f62dae86ae8d2c0"
+
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "databake",
+ "displaydoc",
+ "potential_utf",
+ "serde",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap 0.8.1",
+ "serde",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "serde",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "databake",
+ "displaydoc",
+ "erased-serde",
+ "icu_locale_core",
+ "postcard",
+ "serde",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "is-terminal"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.172"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
+[[package]]
+name = "litemap"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "postcard"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "170a2601f67cc9dba8edd8c4870b15f71a6a2dc196daec8c83f72b59dff628a8"
+dependencies = [
+ "cobs",
+ "serde",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+dependencies = [
+ "serde",
+ "zerovec",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustversion"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.140"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "syn"
+version = "2.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "serde",
+ "zerovec",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b7a6cf4865aac8394f19ad46e37f60b929c1ba5eed798b96a32820aa9392929"
+dependencies = [
+ "displaydoc",
+ "litemap 0.7.5",
+ "serde",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+dependencies = [
+ "databake",
+ "serde",
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/third_party/rust/icu_casemap/Cargo.toml b/third_party/rust/icu_casemap/Cargo.toml
@@ -0,0 +1,161 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.82"
+name = "icu_casemap"
+version = "2.0.1"
+authors = ["The ICU4X Project Developers"]
+build = false
+include = [
+    "data/**/*",
+    "src/**/*",
+    "examples/**/*",
+    "benches/**/*",
+    "tests/**/*",
+    "Cargo.toml",
+    "LICENSE",
+    "README.md",
+    "build.rs",
+]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Unicode case mapping and folding algorithms"
+homepage = "https://icu4x.unicode.org"
+readme = "README.md"
+categories = ["internationalization"]
+license = "Unicode-3.0"
+repository = "https://github.com/unicode-org/icu4x"
+
+[package.metadata.cargo-all-features]
+skip_optional_dependencies = true
+
+[package.metadata.docs.rs]
+all-features = true
+
+[features]
+compiled_data = [
+    "dep:icu_casemap_data",
+    "icu_properties/compiled_data",
+    "icu_provider/baked",
+]
+datagen = [
+    "serde",
+    "dep:databake",
+    "zerovec/databake",
+    "icu_collections/databake",
+    "icu_provider/export",
+]
+default = ["compiled_data"]
+serde = [
+    "dep:serde",
+    "zerovec/serde",
+    "icu_collections/serde",
+    "icu_provider/serde",
+    "icu_properties/serde",
+    "potential_utf/serde",
+]
+
+[lib]
+name = "icu_casemap"
+path = "src/lib.rs"
+
+[[test]]
+name = "conversions"
+path = "tests/conversions.rs"
+required-features = ["compiled_data"]
+
+[[test]]
+name = "gen_greek_to_me"
+path = "tests/gen_greek_to_me.rs"
+harness = false
+required-features = [
+    "compiled_data",
+    "datagen",
+]
+
+[[bench]]
+name = "casemap"
+path = "benches/casemap.rs"
+harness = false
+required-features = ["compiled_data"]
+
+[dependencies.databake]
+version = "0.2.0"
+features = ["derive"]
+optional = true
+default-features = false
+
+[dependencies.displaydoc]
+version = "0.2.3"
+default-features = false
+
+[dependencies.icu_casemap_data]
+version = "~2.0.0"
+optional = true
+default-features = false
+
+[dependencies.icu_collections]
+version = "~2.0.0"
+features = ["alloc"]
+default-features = false
+
+[dependencies.icu_locale_core]
+version = "2.0.0"
+features = ["alloc"]
+default-features = false
+
+[dependencies.icu_properties]
+version = "~2.0.0"
+default-features = false
+
+[dependencies.icu_provider]
+version = "2.0.0"
+features = ["alloc"]
+default-features = false
+
+[dependencies.potential_utf]
+version = "0.1.1"
+features = [
+    "alloc",
+    "zerovec",
+]
+default-features = false
+
+[dependencies.serde]
+version = "1.0.110"
+features = [
+    "derive",
+    "alloc",
+]
+optional = true
+default-features = false
+
+[dependencies.writeable]
+version = "0.6.0"
+default-features = false
+
+[dependencies.zerovec]
+version = "0.11.1"
+features = [
+    "alloc",
+    "yoke",
+]
+default-features = false
+
+[dev-dependencies]
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies.criterion]
+version = "0.5.0"
diff --git a/third_party/rust/icu_casemap/LICENSE b/third_party/rust/icu_casemap/LICENSE
@@ -0,0 +1,46 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2020-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0
+
+—
+
+Portions of ICU4X may have been adapted from ICU4C and/or ICU4J.
+ICU 1.8.1 to ICU 57.1 © 1995-2016 International Business Machines Corporation and others.
diff --git a/third_party/rust/icu_casemap/README.md b/third_party/rust/icu_casemap/README.md
@@ -0,0 +1,34 @@
+# icu_casemap [![crates.io](https://img.shields.io/crates/v/icu_casemap)](https://crates.io/crates/icu_casemap)
+
+<!-- cargo-rdme start -->
+
+Case mapping for Unicode characters and strings.
+
+This module is published as its own crate ([`icu_casemap`](https://docs.rs/icu_casemap/latest/icu_casemap/))
+and as part of the [`icu`](https://docs.rs/icu/latest/icu/) crate. See the latter for more details on the ICU4X project.
+
+## Examples
+
+```rust
+use icu::casemap::CaseMapper;
+use icu::locale::langid;
+
+let cm = CaseMapper::new();
+
+assert_eq!(
+    cm.uppercase_to_string("hello world", &langid!("und")),
+    "HELLO WORLD"
+);
+assert_eq!(
+    cm.lowercase_to_string("Γειά σου Κόσμε", &langid!("und")),
+    "γειά σου κόσμε"
+);
+```
+
+[`ICU4X`]: ../icu/index.html
+
+<!-- cargo-rdme end -->
+
+## More Information
+
+For more information on development, authorship, contributing etc. please visit [`ICU4X home page`](https://github.com/unicode-org/icu4x).
diff --git a/third_party/rust/icu_casemap/benches/casemap.rs b/third_party/rust/icu_casemap/benches/casemap.rs
@@ -0,0 +1,121 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use icu_casemap::CaseMapper;
+use icu_locale_core::langid;
+use icu_normalizer::DecomposingNormalizerBorrowed;
+
+const TEST_STRING_EN: &str = "One of the key design principles of ICU4X is to make locale data small and portable, allowing it to be pulled from multiple sources depending on the needs of the application.  This document explains how that goal can be achieved.";
+
+// First 50 lines of the Iliad, in precomposed Greek
+// (The Iliad is thousands of years old and public domain)
+// Sources can be found in https://www.perseus.tufts.edu/hopper/text?doc=Perseus:text:1999.01.0133 or https://www.sacred-texts.com/cla/homer/greek/ili01.htm
+const ILIAD: &str = include_str!("data/Iliad.txt");
+
+fn overview_bench(c: &mut Criterion) {
+    let casemapper = CaseMapper::new();
+    let root = langid!("und");
+    let tr = langid!("tr");
+    c.bench_function("icu_casemap/overview", |b| {
+        b.iter(|| {
+            black_box(casemapper.lowercase_to_string(black_box(TEST_STRING_EN), &root));
+            black_box(casemapper.uppercase_to_string(black_box(TEST_STRING_EN), &root));
+        });
+    });
+
+    c.bench_function("icu_casemap/titlecase_segment", |b| {
+        b.iter(|| {
+            for s in TEST_STRING_EN.split(' ') {
+                black_box(casemapper.titlecase_segment_with_only_case_data_to_string(
+                    black_box(s),
+                    &root,
+                    Default::default(),
+                ));
+            }
+        });
+    });
+
+    c.bench_function("icu_casemap/folding", |b| {
+        b.iter(|| {
+            black_box(casemapper.fold_string(black_box(TEST_STRING_EN)));
+        });
+    });
+    c.bench_function("icu_casemap/uppercase_tr", |b| {
+        b.iter(|| {
+            black_box(casemapper.uppercase_to_string(black_box(TEST_STRING_EN), &tr));
+        });
+    });
+}
+fn greek_uppercasing(_c: &mut Criterion) {
+    {
+        let c = _c;
+        let casemapper = CaseMapper::new();
+        let root = langid!("und");
+        let el = langid!("el");
+
+        let iliad_lowercase = casemapper.lowercase_to_string(ILIAD, &root);
+        let decomposer = DecomposingNormalizerBorrowed::new_nfd();
+        let nfd = decomposer.normalize_utf8(ILIAD.as_bytes());
+        let nfd_lowercase = decomposer.normalize_utf8(iliad_lowercase.as_bytes());
+
+        let mut group =
+            c.benchmark_group("icu_casemap/greek_uppercasing/precomposed/upper_from_title");
+        group.bench_function("root", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(ILIAD), &root));
+            });
+        });
+        group.bench_function("greek", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(ILIAD), &el));
+            });
+        });
+        group.finish();
+
+        let mut group =
+            c.benchmark_group("icu_casemap/greek_uppercasing/precomposed/upper_from_lower");
+        group.bench_function("root", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(&iliad_lowercase), &root));
+            });
+        });
+        group.bench_function("greek", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(&iliad_lowercase), &el));
+            });
+        });
+        group.finish();
+
+        let mut group =
+            c.benchmark_group("icu_casemap/greek_uppercasing/decomposed/upper_from_title");
+        group.bench_function("root", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(&nfd), &root));
+            });
+        });
+        group.bench_function("greek", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(&nfd), &el));
+            });
+        });
+        group.finish();
+
+        let mut group =
+            c.benchmark_group("icu_casemap/greek_uppercasing/decomposed/upper_from_lower");
+        group.bench_function("root", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(&nfd_lowercase), &root));
+            });
+        });
+        group.bench_function("greek", |b| {
+            b.iter(|| {
+                black_box(casemapper.uppercase_to_string(black_box(&nfd_lowercase), &el));
+            });
+        });
+        group.finish();
+    }
+}
+criterion_group!(benches, overview_bench, greek_uppercasing);
+criterion_main!(benches);
diff --git a/third_party/rust/icu_casemap/benches/data/Iliad.txt b/third_party/rust/icu_casemap/benches/data/Iliad.txt
@@ -0,0 +1,49 @@
+μῆνιν ἄειδε θεὰ Πηληϊάδεω Ἀχιλῆος
+οὐλομένην, ἣ μυρί᾽ Ἀχαιοῖς ἄλγε᾽ ἔθηκε,
+πολλὰς δ᾽ ἰφθίμους ψυχὰς Ἄϊδι προΐαψεν
+ἡρώων, αὐτοὺς δὲ ἑλώρια τεῦχε κύνεσσιν
+5οἰωνοῖσί τε πᾶσι, Διὸς δ᾽ ἐτελείετο βουλή,
+ἐξ οὗ δὴ τὰ πρῶτα διαστήτην ἐρίσαντε
+Ἀτρεΐδης τε ἄναξ ἀνδρῶν καὶ δῖος Ἀχιλλεύς.
+τίς τ᾽ ἄρ σφωε θεῶν ἔριδι ξυνέηκε μάχεσθαι;
+Λητοῦς καὶ Διὸς υἱός: ὃ γὰρ βασιλῆϊ χολωθεὶς
+10νοῦσον ἀνὰ στρατὸν ὄρσε κακήν, ὀλέκοντο δὲ λαοί,
+οὕνεκα τὸν Χρύσην ἠτίμασεν ἀρητῆρα
+Ἀτρεΐδης: ὃ γὰρ ἦλθε θοὰς ἐπὶ νῆας Ἀχαιῶν
+λυσόμενός τε θύγατρα φέρων τ᾽ ἀπερείσι᾽ ἄποινα,
+στέμματ᾽ ἔχων ἐν χερσὶν ἑκηβόλου Ἀπόλλωνος
+15χρυσέῳ ἀνὰ σκήπτρῳ, καὶ λίσσετο πάντας Ἀχαιούς,
+Ἀτρεΐδα δὲ μάλιστα δύω, κοσμήτορε λαῶν:
+Ἀτρεΐδαι τε καὶ ἄλλοι ἐϋκνήμιδες Ἀχαιοί,
+ὑμῖν μὲν θεοὶ δοῖεν Ὀλύμπια δώματ᾽ ἔχοντες
+ἐκπέρσαι Πριάμοιο πόλιν, εὖ δ᾽ οἴκαδ᾽ ἱκέσθαι:
+20παῖδα δ᾽ ἐμοὶ λύσαιτε φίλην, τὰ δ᾽ ἄποινα δέχεσθαι,
+ἁζόμενοι Διὸς υἱὸν ἑκηβόλον Ἀπόλλωνα.
+ἔνθ᾽ ἄλλοι μὲν πάντες ἐπευφήμησαν Ἀχαιοὶ
+αἰδεῖσθαί θ᾽ ἱερῆα καὶ ἀγλαὰ δέχθαι ἄποινα:
+ἀλλ᾽ οὐκ Ἀτρεΐδῃ Ἀγαμέμνονι ἥνδανε θυμῷ,
+25ἀλλὰ κακῶς ἀφίει, κρατερὸν δ᾽ ἐπὶ μῦθον ἔτελλε:
+μή σε γέρον κοίλῃσιν ἐγὼ παρὰ νηυσὶ κιχείω
+ἢ νῦν δηθύνοντ᾽ ἢ ὕστερον αὖτις ἰόντα,
+μή νύ τοι οὐ χραίσμῃ σκῆπτρον καὶ στέμμα θεοῖο:
+τὴν δ᾽ ἐγὼ οὐ λύσω: πρίν μιν καὶ γῆρας ἔπεισιν
+30ἡμετέρῳ ἐνὶ οἴκῳ ἐν Ἄργεϊ τηλόθι πάτρης
+ἱστὸν ἐποιχομένην καὶ ἐμὸν λέχος ἀντιόωσαν:
+ἀλλ᾽ ἴθι μή μ᾽ ἐρέθιζε σαώτερος ὥς κε νέηαι.
+ὣς ἔφατ᾽, ἔδεισεν δ᾽ ὃ γέρων καὶ ἐπείθετο μύθῳ:
+βῆ δ᾽ ἀκέων παρὰ θῖνα πολυφλοίσβοιο θαλάσσης:
+35πολλὰ δ᾽ ἔπειτ᾽ ἀπάνευθε κιὼν ἠρᾶθ᾽ ὃ γεραιὸς
+Ἀπόλλωνι ἄνακτι, τὸν ἠΰκομος τέκε Λητώ:
+κλῦθί μευ ἀργυρότοξ᾽, ὃς Χρύσην ἀμφιβέβηκας
+Κίλλάν τε ζαθέην Τενέδοιό τε ἶφι ἀνάσσεις,
+Σμινθεῦ εἴ ποτέ τοι χαρίεντ᾽ ἐπὶ νηὸν ἔρεψα,
+40ἢ εἰ δή ποτέ τοι κατὰ πίονα μηρί᾽ ἔκηα
+ταύρων ἠδ᾽ αἰγῶν, τὸ δέ μοι κρήηνον ἐέλδωρ:
+τίσειαν Δαναοὶ ἐμὰ δάκρυα σοῖσι βέλεσσιν.
+ὣς ἔφατ᾽ εὐχόμενος, τοῦ δ᾽ ἔκλυε Φοῖβος Ἀπόλλων,
+βῆ δὲ κατ᾽ Οὐλύμποιο καρήνων χωόμενος κῆρ,
+45τόξ᾽ ὤμοισιν ἔχων ἀμφηρεφέα τε φαρέτρην:
+ἔκλαγξαν δ᾽ ἄρ᾽ ὀϊστοὶ ἐπ᾽ ὤμων χωομένοιο,
+αὐτοῦ κινηθέντος: ὃ δ᾽ ἤϊε νυκτὶ ἐοικώς.
+ἕζετ᾽ ἔπειτ᾽ ἀπάνευθε νεῶν, μετὰ δ᾽ ἰὸν ἕηκε:
+δεινὴ δὲ κλαγγὴ γένετ᾽ ἀργυρέοιο βιοῖο:
+\ No newline at end of file
diff --git a/third_party/rust/icu_casemap/src/casemapper.rs b/third_party/rust/icu_casemap/src/casemapper.rs
@@ -0,0 +1,806 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::internals::{CaseMapLocale, FoldOptions, FullCaseWriteable, StringAndWriteable};
+use crate::provider::data::MappingKind;
+use crate::provider::CaseMap;
+use crate::provider::CaseMapV1;
+use crate::set::ClosureSink;
+use crate::titlecase::{LeadingAdjustment, TitlecaseOptions, TrailingCase};
+use alloc::borrow::Cow;
+use icu_locale_core::LanguageIdentifier;
+use icu_provider::prelude::*;
+use writeable::Writeable;
+
+/// A struct with the ability to convert characters and strings to uppercase or lowercase,
+/// or fold them to a normalized form for case-insensitive comparison.
+///
+/// Most methods for this type live on [`CaseMapperBorrowed`], which you can obtain via
+/// [`CaseMapper::new()`] or [`CaseMapper::as_borrowed()`].
+///
+/// # Examples
+///
+/// ```rust
+/// use icu::casemap::CaseMapper;
+/// use icu::locale::langid;
+///
+/// let cm = CaseMapper::new();
+///
+/// assert_eq!(
+///     cm.uppercase_to_string("hello world", &langid!("und")),
+///     "HELLO WORLD"
+/// );
+/// assert_eq!(
+///     cm.lowercase_to_string("Γειά σου Κόσμε", &langid!("und")),
+///     "γειά σου κόσμε"
+/// );
+/// ```
+#[derive(Clone, Debug)]
+pub struct CaseMapper {
+    pub(crate) data: DataPayload<CaseMapV1>,
+}
+
+impl AsRef<CaseMapper> for CaseMapper {
+    fn as_ref(&self) -> &CaseMapper {
+        self
+    }
+}
+
+/// A struct with the ability to convert characters and strings to uppercase or lowercase,
+/// or fold them to a normalized form for case-insensitive comparison, borrowed version.
+///
+/// See methods or [`CaseMapper`] for examples.
+#[derive(Clone, Debug, Copy)]
+pub struct CaseMapperBorrowed<'a> {
+    pub(crate) data: &'a CaseMap<'a>,
+}
+
+impl CaseMapperBorrowed<'static> {
+    /// Cheaply converts a [`CaseMapperBorrowed<'static>`] into a [`CaseMapper`].
+    ///
+    /// Note: Due to branching and indirection, using [`CaseMapper`] might inhibit some
+    /// compile-time optimizations that are possible with [`CaseMapperBorrowed`].
+    pub const fn static_to_owned(self) -> CaseMapper {
+        CaseMapper {
+            data: DataPayload::from_static_ref(self.data),
+        }
+    }
+    /// Creates a [`CaseMapperBorrowed`] using compiled data.
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// assert_eq!(
+    ///     cm.uppercase_to_string("hello world", &langid!("und")),
+    ///     "HELLO WORLD"
+    /// );
+    /// ```
+    #[cfg(feature = "compiled_data")]
+    pub const fn new() -> Self {
+        Self {
+            data: crate::provider::Baked::SINGLETON_CASE_MAP_V1,
+        }
+    }
+}
+
+#[cfg(feature = "compiled_data")]
+impl Default for CaseMapperBorrowed<'static> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> CaseMapperBorrowed<'a> {
+    /// Returns the full lowercase mapping of the given string as a [`Writeable`].
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// See [`Self::lowercase_to_string()`] for the equivalent convenience function that returns a string,
+    /// as well as for an example.
+    pub fn lowercase(self, src: &'a str, langid: &LanguageIdentifier) -> impl Writeable + 'a {
+        self.data.full_helper_writeable::<false>(
+            src,
+            CaseMapLocale::from_langid(langid),
+            MappingKind::Lower,
+            TrailingCase::default(),
+        )
+    }
+
+    /// Returns the full uppercase mapping of the given string as a [`Writeable`].
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// See [`Self::uppercase_to_string()`] for the equivalent convenience function that returns a string,
+    /// as well as for an example.
+    pub fn uppercase(self, src: &'a str, langid: &LanguageIdentifier) -> impl Writeable + 'a {
+        self.data.full_helper_writeable::<false>(
+            src,
+            CaseMapLocale::from_langid(langid),
+            MappingKind::Upper,
+            TrailingCase::default(),
+        )
+    }
+
+    /// Returns the full titlecase mapping of the given string as a [`Writeable`], treating
+    /// the string as a single segment (and thus only titlecasing the beginning of it). Performs
+    /// the specified leading adjustment behavior from the options without loading additional data.
+    ///
+    /// This should typically be used as a lower-level helper to construct the titlecasing operation desired
+    /// by the application, for example one can titlecase on a per-word basis by mixing this with
+    /// a `WordSegmenter`.
+    ///
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// This function performs "adjust to cased" leading adjustment behavior when [`LeadingAdjustment::Auto`] or [`LeadingAdjustment::ToCased`]
+    /// is set. Auto mode is not able to pick the "adjust to letter/number/symbol" behavior as this type does not load
+    /// the data to do so, use [`TitlecaseMapper`] if such behavior is desired. See
+    /// the docs of [`TitlecaseMapper`] for more information on what this means. There is no difference between
+    /// the behavior of this function and the equivalent ones on [`TitlecaseMapper`] when the head adjustment mode
+    /// is [`LeadingAdjustment::None`].
+    ///
+    /// See [`Self::titlecase_segment_with_only_case_data_to_string()`] for the equivalent convenience function that returns a string,
+    /// as well as for an example.
+    ///
+    /// [`TitlecaseMapper`]: crate::TitlecaseMapper
+    pub fn titlecase_segment_with_only_case_data(
+        self,
+        src: &'a str,
+        langid: &LanguageIdentifier,
+        options: TitlecaseOptions,
+    ) -> impl Writeable + 'a {
+        self.titlecase_segment_with_adjustment(src, langid, options, |data, ch| data.is_cased(ch))
+    }
+
+    /// Helper to support different leading adjustment behaviors,
+    /// `char_is_lead` is a function that returns true for a character that is allowed to be the
+    /// first relevant character in a titlecasing string, when `leading_adjustment != None`
+    ///
+    /// We return a concrete type instead of `impl Trait` so the return value can be mixed with that of other calls
+    /// to this function with different closures
+    pub(crate) fn titlecase_segment_with_adjustment(
+        self,
+        src: &'a str,
+        langid: &LanguageIdentifier,
+        options: TitlecaseOptions,
+        char_is_lead: impl Fn(&CaseMap, char) -> bool,
+    ) -> StringAndWriteable<'a, FullCaseWriteable<'a, 'a, true>> {
+        let (head, rest) = match options.leading_adjustment.unwrap_or_default() {
+            LeadingAdjustment::Auto | LeadingAdjustment::ToCased => {
+                let first_cased = src
+                    .char_indices()
+                    .find(|(_i, ch)| char_is_lead(self.data, *ch));
+                if let Some((first_cased, _ch)) = first_cased {
+                    (
+                        src.get(..first_cased).unwrap_or(""),
+                        src.get(first_cased..).unwrap_or(""),
+                    )
+                } else {
+                    (src, "")
+                }
+            }
+            LeadingAdjustment::None => ("", src),
+        };
+        let writeable = self.data.full_helper_writeable::<true>(
+            rest,
+            CaseMapLocale::from_langid(langid),
+            MappingKind::Title,
+            options.trailing_case.unwrap_or_default(),
+        );
+        StringAndWriteable {
+            string: head,
+            writeable,
+        }
+    }
+    /// Case-folds the characters in the given string as a [`Writeable`].
+    /// This function is locale-independent and context-insensitive.
+    ///
+    /// Can be used to test if two strings are case-insensitively equivalent.
+    ///
+    /// See [`Self::fold_string()`] for the equivalent convenience function that returns a string,
+    /// as well as for an example.
+    pub fn fold(self, src: &'a str) -> impl Writeable + 'a {
+        self.data.full_helper_writeable::<false>(
+            src,
+            CaseMapLocale::Root,
+            MappingKind::Fold,
+            TrailingCase::default(),
+        )
+    }
+
+    /// Case-folds the characters in the given string as a [`Writeable`],
+    /// using Turkic (T) mappings for dotted/dotless I.
+    /// This function is locale-independent and context-insensitive.
+    ///
+    /// Can be used to test if two strings are case-insensitively equivalent.
+    ///
+    /// See [`Self::fold_turkic_string()`] for the equivalent convenience function that returns a string,
+    /// as well as for an example.
+    pub fn fold_turkic(self, src: &'a str) -> impl Writeable + 'a {
+        self.data.full_helper_writeable::<false>(
+            src,
+            CaseMapLocale::Turkish,
+            MappingKind::Fold,
+            TrailingCase::default(),
+        )
+    }
+
+    /// Returns the full lowercase mapping of the given string as a string.
+    ///
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// See [`Self::lowercase()`] for the equivalent lower-level function that returns a [`Writeable`]
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = CaseMapper::new();
+    /// let root = langid!("und");
+    ///
+    /// assert_eq!(cm.lowercase_to_string("hEllO WorLd", &root), "hello world");
+    /// assert_eq!(cm.lowercase_to_string("Γειά σου Κόσμε", &root), "γειά σου κόσμε");
+    /// assert_eq!(cm.lowercase_to_string("नमस्ते दुनिया", &root), "नमस्ते दुनिया");
+    /// assert_eq!(cm.lowercase_to_string("Привет мир", &root), "привет мир");
+    ///
+    /// // Some behavior is language-sensitive
+    /// assert_eq!(cm.lowercase_to_string("CONSTANTINOPLE", &root), "constantinople");
+    /// assert_eq!(cm.lowercase_to_string("CONSTANTINOPLE", &langid!("tr")), "constantınople");
+    /// ```
+    pub fn lowercase_to_string<'s>(
+        self,
+        src: &'s str,
+        langid: &LanguageIdentifier,
+    ) -> Cow<'s, str> {
+        writeable::to_string_or_borrow(&self.lowercase(src, langid), src.as_bytes())
+    }
+
+    /// Returns the full uppercase mapping of the given string as a string.
+    ///
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// See [`Self::uppercase()`] for the equivalent lower-level function that returns a [`Writeable`]
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = CaseMapper::new();
+    /// let root = langid!("und");
+    ///
+    /// assert_eq!(cm.uppercase_to_string("hEllO WorLd", &root), "HELLO WORLD");
+    /// assert_eq!(cm.uppercase_to_string("Γειά σου Κόσμε", &root), "ΓΕΙΆ ΣΟΥ ΚΌΣΜΕ");
+    /// assert_eq!(cm.uppercase_to_string("नमस्ते दुनिया", &root), "नमस्ते दुनिया");
+    /// assert_eq!(cm.uppercase_to_string("Привет мир", &root), "ПРИВЕТ МИР");
+    ///
+    /// // Some behavior is language-sensitive
+    /// assert_eq!(cm.uppercase_to_string("istanbul", &root), "ISTANBUL");
+    /// assert_eq!(cm.uppercase_to_string("istanbul", &langid!("tr")), "İSTANBUL"); // Turkish dotted i
+    ///
+    /// assert_eq!(cm.uppercase_to_string("և Երևանի", &root), "ԵՒ ԵՐԵՒԱՆԻ");
+    /// assert_eq!(cm.uppercase_to_string("և Երևանի", &langid!("hy")), "ԵՎ ԵՐԵՎԱՆԻ"); // Eastern Armenian ech-yiwn ligature
+    /// ```
+    pub fn uppercase_to_string<'s>(
+        self,
+        src: &'s str,
+        langid: &LanguageIdentifier,
+    ) -> Cow<'s, str> {
+        writeable::to_string_or_borrow(&self.uppercase(src, langid), src.as_bytes())
+    }
+
+    /// Returns the full titlecase mapping of the given string as a [`Writeable`], treating
+    /// the string as a single segment (and thus only titlecasing the beginning of it). Performs
+    /// the specified leading adjustment behavior from the options without loading additional data.
+    ///
+    /// Note that [`TitlecaseMapper`] has better behavior, most users should consider using
+    /// it instead. This method primarily exists for people who care about the amount of data being loaded.
+    ///
+    /// This should typically be used as a lower-level helper to construct the titlecasing operation desired
+    /// by the application, for example one can titlecase on a per-word basis by mixing this with
+    /// a `WordSegmenter`.
+    ///
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// This function performs "adjust to cased" leading adjustment behavior when [`LeadingAdjustment::Auto`] or [`LeadingAdjustment::ToCased`]
+    /// is set. Auto mode is not able to pick the "adjust to letter/number/symbol" behavior as this type does not load
+    /// the data to do so, use [`TitlecaseMapper`] if such behavior is desired. See
+    /// the docs of [`TitlecaseMapper`] for more information on what this means. There is no difference between
+    /// the behavior of this function and the equivalent ones on [`TitlecaseMapper`] when the head adjustment mode
+    /// is [`LeadingAdjustment::None`].
+    ///
+    /// See [`Self::titlecase_segment_with_only_case_data()`] for the equivalent lower-level function that returns a [`Writeable`]
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = CaseMapper::new();
+    /// let root = langid!("und");
+    ///
+    /// let default_options = Default::default();
+    ///
+    /// // note that the subsequent words are not titlecased, this function assumes
+    /// // that the entire string is a single segment and only titlecases at the beginning.
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("hEllO WorLd", &root, default_options), "Hello world");
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("Γειά σου Κόσμε", &root, default_options), "Γειά σου κόσμε");
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("नमस्ते दुनिया", &root, default_options), "नमस्ते दुनिया");
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("Привет мир", &root, default_options), "Привет мир");
+    ///
+    /// // Some behavior is language-sensitive
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("istanbul", &root, default_options), "Istanbul");
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("istanbul", &langid!("tr"), default_options), "İstanbul"); // Turkish dotted i
+    ///
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("և Երևանի", &root, default_options), "Եւ երևանի");
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("և Երևանի", &langid!("hy"), default_options), "Եվ երևանի"); // Eastern Armenian ech-yiwn ligature
+    ///
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("ijkdijk", &root, default_options), "Ijkdijk");
+    /// assert_eq!(cm.titlecase_segment_with_only_case_data_to_string("ijkdijk", &langid!("nl"), default_options), "IJkdijk"); // Dutch IJ digraph
+    /// ```
+    ///
+    /// [`TitlecaseMapper`]: crate::TitlecaseMapper
+    pub fn titlecase_segment_with_only_case_data_to_string<'s>(
+        self,
+        src: &'s str,
+        langid: &LanguageIdentifier,
+        options: TitlecaseOptions,
+    ) -> Cow<'s, str> {
+        writeable::to_string_or_borrow(
+            &self.titlecase_segment_with_only_case_data(src, langid, options),
+            src.as_bytes(),
+        )
+    }
+
+    /// Case-folds the characters in the given string as a String.
+    /// This function is locale-independent and context-insensitive.
+    ///
+    /// Can be used to test if two strings are case-insensitively equivalent.
+    ///
+    /// See [`Self::fold()`] for the equivalent lower-level function that returns a [`Writeable`]
+    ///s s
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// // Check if two strings are equivalent case insensitively
+    /// assert_eq!(cm.fold_string("hEllO WorLd"), cm.fold_string("HELLO worlD"));
+    ///
+    /// assert_eq!(cm.fold_string("hEllO WorLd"), "hello world");
+    /// assert_eq!(cm.fold_string("Γειά σου Κόσμε"), "γειά σου κόσμε");
+    /// assert_eq!(cm.fold_string("नमस्ते दुनिया"), "नमस्ते दुनिया");
+    /// assert_eq!(cm.fold_string("Привет мир"), "привет мир");
+    /// ```
+    pub fn fold_string(self, src: &str) -> Cow<str> {
+        writeable::to_string_or_borrow(&self.fold(src), src.as_bytes())
+    }
+
+    /// Case-folds the characters in the given string as a String,
+    /// using Turkic (T) mappings for dotted/dotless I.
+    /// This function is locale-independent and context-insensitive.
+    ///
+    /// Can be used to test if two strings are case-insensitively equivalent.
+    ///
+    /// See [`Self::fold_turkic()`] for the equivalent lower-level function that returns a [`Writeable`]
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// // Check if two strings are equivalent case insensitively
+    /// assert_eq!(cm.fold_turkic_string("İstanbul"), cm.fold_turkic_string("iSTANBUL"));
+    ///
+    /// assert_eq!(cm.fold_turkic_string("İstanbul not Constantinople"), "istanbul not constantinople");
+    /// assert_eq!(cm.fold_turkic_string("Istanbul not Constantınople"), "ıstanbul not constantınople");
+    ///
+    /// assert_eq!(cm.fold_turkic_string("hEllO WorLd"), "hello world");
+    /// assert_eq!(cm.fold_turkic_string("Γειά σου Κόσμε"), "γειά σου κόσμε");
+    /// assert_eq!(cm.fold_turkic_string("नमस्ते दुनिया"), "नमस्ते दुनिया");
+    /// assert_eq!(cm.fold_turkic_string("Привет мир"), "привет мир");
+    /// ```
+    pub fn fold_turkic_string(self, src: &str) -> Cow<str> {
+        writeable::to_string_or_borrow(&self.fold_turkic(src), src.as_bytes())
+    }
+
+    /// Adds all simple case mappings and the full case folding for `c` to `set`.
+    /// Also adds special case closure mappings.
+    ///
+    /// Identical to [`CaseMapCloserBorrowed::add_case_closure_to()`], see docs there for more information.
+    /// This method is duplicated so that one does not need to load extra unfold data
+    /// if they only need this and not also [`CaseMapCloserBorrowed::add_string_case_closure_to()`].
+    ///
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    /// use icu::collections::codepointinvlist::CodePointInversionListBuilder;
+    ///
+    /// let cm = CaseMapper::new();
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// cm.add_case_closure_to('s', &mut builder);
+    ///
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('S'));
+    /// assert!(set.contains('ſ'));
+    /// assert!(!set.contains('s')); // does not contain itself
+    /// ```
+    ///
+    /// [`CaseMapCloserBorrowed::add_case_closure_to()`]: crate::CaseMapCloserBorrowed::add_case_closure_to
+    /// [`CaseMapCloserBorrowed::add_string_case_closure_to()`]: crate::CaseMapCloserBorrowed::add_string_case_closure_to
+    pub fn add_case_closure_to<S: ClosureSink>(self, c: char, set: &mut S) {
+        self.data.add_case_closure_to(c, set);
+    }
+
+    /// Returns the lowercase mapping of the given `char`.
+    /// This function only implements simple and common mappings. Full mappings,
+    /// which can map one `char` to a string, are not included.
+    /// For full mappings, use [`CaseMapperBorrowed::lowercase`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// assert_eq!(cm.simple_lowercase('C'), 'c');
+    /// assert_eq!(cm.simple_lowercase('c'), 'c');
+    /// assert_eq!(cm.simple_lowercase('Ć'), 'ć');
+    /// assert_eq!(cm.simple_lowercase('Γ'), 'γ');
+    /// ```
+    pub fn simple_lowercase(self, c: char) -> char {
+        self.data.simple_lower(c)
+    }
+
+    /// Returns the uppercase mapping of the given `char`.
+    /// This function only implements simple and common mappings. Full mappings,
+    /// which can map one `char` to a string, are not included.
+    /// For full mappings, use [`CaseMapperBorrowed::uppercase`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// assert_eq!(cm.simple_uppercase('c'), 'C');
+    /// assert_eq!(cm.simple_uppercase('C'), 'C');
+    /// assert_eq!(cm.simple_uppercase('ć'), 'Ć');
+    /// assert_eq!(cm.simple_uppercase('γ'), 'Γ');
+    ///
+    /// assert_eq!(cm.simple_uppercase('ǳ'), 'Ǳ');
+    /// ```
+    pub fn simple_uppercase(self, c: char) -> char {
+        self.data.simple_upper(c)
+    }
+
+    /// Returns the titlecase mapping of the given `char`.
+    /// This function only implements simple and common mappings. Full mappings,
+    /// which can map one `char` to a string, are not included.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// assert_eq!(cm.simple_titlecase('ǳ'), 'ǲ');
+    ///
+    /// assert_eq!(cm.simple_titlecase('c'), 'C');
+    /// assert_eq!(cm.simple_titlecase('C'), 'C');
+    /// assert_eq!(cm.simple_titlecase('ć'), 'Ć');
+    /// assert_eq!(cm.simple_titlecase('γ'), 'Γ');
+    /// ```
+    pub fn simple_titlecase(self, c: char) -> char {
+        self.data.simple_title(c)
+    }
+
+    /// Returns the simple case folding of the given char.
+    /// For full mappings, use [`CaseMapperBorrowed::fold`].
+    ///
+    /// This function can be used to perform caseless matches on
+    /// individual characters.
+    /// > *Note:* With Unicode 15.0 data, there are three
+    /// > pairs of characters for which equivalence under this
+    /// > function is inconsistent with equivalence of the
+    /// > one-character strings under [`CaseMapperBorrowed::fold`].
+    /// > This is resolved in Unicode 15.1 and later.
+    ///
+    /// For compatibility applications where simple case folding
+    /// of strings is required, this function can be applied to
+    /// each character of a string.  Note that the resulting
+    /// equivalence relation is different from that obtained
+    /// by [`CaseMapperBorrowed::fold`]:
+    /// The strings "Straße" and "STRASSE" are distinct
+    /// under simple case folding, but are equivalent under
+    /// default (full) case folding.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// // perform case insensitive checks
+    /// assert_eq!(cm.simple_fold('σ'), cm.simple_fold('ς'));
+    /// assert_eq!(cm.simple_fold('Σ'), cm.simple_fold('ς'));
+    ///
+    /// assert_eq!(cm.simple_fold('c'), 'c');
+    /// assert_eq!(cm.simple_fold('Ć'), 'ć');
+    /// assert_eq!(cm.simple_fold('Γ'), 'γ');
+    /// assert_eq!(cm.simple_fold('ς'), 'σ');
+    ///
+    /// assert_eq!(cm.simple_fold('ß'), 'ß');
+    /// assert_eq!(cm.simple_fold('I'), 'i');
+    /// assert_eq!(cm.simple_fold('İ'), 'İ');
+    /// assert_eq!(cm.simple_fold('ı'), 'ı');
+    /// ```
+    pub fn simple_fold(self, c: char) -> char {
+        self.data.simple_fold(c, FoldOptions::default())
+    }
+
+    /// Returns the simple case folding of the given char, using Turkic (T) mappings for
+    /// dotted/dotless i. This function does not fold `i` and `I` to the same character. Instead,
+    /// `I` will fold to `ı`, and `İ` will fold to `i`. Otherwise, this is the same as
+    /// [`CaseMapperBorrowed::fold()`].
+    ///
+    /// You can use the case folding to perform Turkic caseless matches on characters
+    /// provided they don't full-casefold to strings. To avoid that situation,
+    /// convert to a string and use [`CaseMapperBorrowed::fold_turkic`].
+    ///
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// assert_eq!(cm.simple_fold_turkic('I'), 'ı');
+    /// assert_eq!(cm.simple_fold_turkic('İ'), 'i');
+    /// ```
+    pub fn simple_fold_turkic(self, c: char) -> char {
+        self.data
+            .simple_fold(c, FoldOptions::with_turkic_mappings())
+    }
+}
+
+impl CaseMapper {
+    /// Creates a [`CaseMapperBorrowed`] using compiled data.
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = CaseMapper::new();
+    ///
+    /// assert_eq!(
+    ///     cm.uppercase_to_string("hello world", &langid!("und")),
+    ///     "HELLO WORLD"
+    /// );
+    /// ```
+    #[cfg(feature = "compiled_data")]
+    #[allow(clippy::new_ret_no_self)] // Intentional
+    pub const fn new() -> CaseMapperBorrowed<'static> {
+        CaseMapperBorrowed::new()
+    }
+
+    /// Constructs a borrowed version of this type for more efficient querying.
+    pub fn as_borrowed(&self) -> CaseMapperBorrowed<'_> {
+        CaseMapperBorrowed {
+            data: self.data.get(),
+        }
+    }
+
+    icu_provider::gen_buffer_data_constructors!(() -> error: DataError,
+    functions: [
+        new: skip,
+        try_new_with_buffer_provider,
+        try_new_unstable,
+        Self,
+    ]);
+
+    #[doc = icu_provider::gen_buffer_unstable_docs!(UNSTABLE, Self::new)]
+    pub fn try_new_unstable<P>(provider: &P) -> Result<CaseMapper, DataError>
+    where
+        P: DataProvider<CaseMapV1> + ?Sized,
+    {
+        let data = provider.load(Default::default())?.payload;
+        Ok(Self { data })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use icu_locale_core::langid;
+
+    #[test]
+    /// Tests for SpecialCasing.txt. Some of the special cases are data-driven, some are code-driven
+    fn test_special_cases() {
+        let cm = CaseMapper::new();
+        let root = langid!("und");
+        let default_options = Default::default();
+
+        // Ligatures
+
+        // U+FB00 LATIN SMALL LIGATURE FF
+        assert_eq!(cm.uppercase_to_string("ﬀ", &root), "FF");
+        // U+FB05 LATIN SMALL LIGATURE LONG S T
+        assert_eq!(cm.uppercase_to_string("ﬅ", &root), "ST");
+
+        // No corresponding uppercased character
+
+        // U+0149 LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+        assert_eq!(cm.uppercase_to_string("ŉ", &root), "ʼN");
+
+        // U+1F50 GREEK SMALL LETTER UPSILON WITH PSILI
+        assert_eq!(cm.uppercase_to_string("ὐ", &root), "Υ̓");
+        // U+1FF6 GREEK SMALL LETTER OMEGA WITH PERISPOMENI
+        assert_eq!(cm.uppercase_to_string("ῶ", &root), "Ω͂");
+
+        // YPOGEGRAMMENI / PROSGEGRAMMENI special cases
+
+        // E.g. <alpha><iota_subscript><acute> is uppercased to <ALPHA><acute><IOTA>
+        assert_eq!(
+            cm.uppercase_to_string("α\u{0313}\u{0345}", &root),
+            "Α\u{0313}Ι"
+        );
+        // but the YPOGEGRAMMENI should not titlecase
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string(
+                "α\u{0313}\u{0345}",
+                &root,
+                default_options
+            ),
+            "Α\u{0313}\u{0345}"
+        );
+
+        // U+1F80 GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("ᾀ", &root, default_options),
+            "ᾈ"
+        );
+        assert_eq!(cm.uppercase_to_string("ᾀ", &root), "ἈΙ");
+
+        // U+1FFC GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+        assert_eq!(cm.lowercase_to_string("ῼ", &root), "ῳ");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("ῼ", &root, default_options),
+            "ῼ"
+        );
+        assert_eq!(cm.uppercase_to_string("ῼ", &root), "ΩΙ");
+
+        // U+1F98 GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
+        assert_eq!(cm.lowercase_to_string("ᾘ", &root), "ᾐ");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("ᾘ", &root, default_options),
+            "ᾘ"
+        );
+        assert_eq!(cm.uppercase_to_string("ᾘ", &root), "ἨΙ");
+
+        // U+1FB2 GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
+        assert_eq!(cm.lowercase_to_string("ᾲ", &root), "ᾲ");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("ᾲ", &root, default_options),
+            "Ὰ\u{345}"
+        );
+        assert_eq!(cm.uppercase_to_string("ᾲ", &root), "ᾺΙ");
+
+        // Final sigma test
+        // U+03A3 GREEK CAPITAL LETTER SIGMA in Final_Sigma context
+        assert_eq!(cm.lowercase_to_string("ΙΙΙΣ", &root), "ιιις");
+
+        // Turkish / Azeri
+        let tr = langid!("tr");
+        let az = langid!("az");
+        // U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE
+        assert_eq!(cm.lowercase_to_string("İ", &tr), "i");
+        assert_eq!(cm.lowercase_to_string("İ", &az), "i");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("İ", &tr, default_options),
+            "İ"
+        );
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("İ", &az, default_options),
+            "İ"
+        );
+        assert_eq!(cm.uppercase_to_string("İ", &tr), "İ");
+        assert_eq!(cm.uppercase_to_string("İ", &az), "İ");
+
+        // U+0049 LATIN CAPITAL LETTER I and U+0307 COMBINING DOT ABOVE
+        assert_eq!(cm.lowercase_to_string("I\u{0307}", &tr), "i");
+        assert_eq!(cm.lowercase_to_string("I\u{0307}", &az), "i");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("I\u{0307}", &tr, default_options),
+            "I\u{0307}"
+        );
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("I\u{0307}", &az, default_options),
+            "I\u{0307}"
+        );
+        assert_eq!(cm.uppercase_to_string("I\u{0307}", &tr), "I\u{0307}");
+        assert_eq!(cm.uppercase_to_string("I\u{0307}", &az), "I\u{0307}");
+
+        // U+0049 LATIN CAPITAL LETTER I
+        assert_eq!(cm.lowercase_to_string("I", &tr), "ı");
+        assert_eq!(cm.lowercase_to_string("I", &az), "ı");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("I", &tr, default_options),
+            "I"
+        );
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("I", &az, default_options),
+            "I"
+        );
+        assert_eq!(cm.uppercase_to_string("I", &tr), "I");
+        assert_eq!(cm.uppercase_to_string("I", &az), "I");
+
+        // U+0069 LATIN SMALL LETTER I
+        assert_eq!(cm.lowercase_to_string("i", &tr), "i");
+        assert_eq!(cm.lowercase_to_string("i", &az), "i");
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("i", &tr, default_options),
+            "İ"
+        );
+        assert_eq!(
+            cm.titlecase_segment_with_only_case_data_to_string("i", &az, default_options),
+            "İ"
+        );
+        assert_eq!(cm.uppercase_to_string("i", &tr), "İ");
+        assert_eq!(cm.uppercase_to_string("i", &az), "İ");
+    }
+
+    #[test]
+    fn test_cherokee_case_folding() {
+        let case_mapping = CaseMapper::new();
+        assert_eq!(case_mapping.simple_fold('Ꭰ'), 'Ꭰ');
+        assert_eq!(case_mapping.simple_fold('ꭰ'), 'Ꭰ');
+        assert_eq!(case_mapping.simple_fold_turkic('Ꭰ'), 'Ꭰ');
+        assert_eq!(case_mapping.simple_fold_turkic('ꭰ'), 'Ꭰ');
+        assert_eq!(case_mapping.fold_string("Ꭰ"), "Ꭰ");
+        assert_eq!(case_mapping.fold_string("ꭰ"), "Ꭰ");
+        assert_eq!(case_mapping.fold_turkic_string("Ꭰ"), "Ꭰ");
+        assert_eq!(case_mapping.fold_turkic_string("ꭰ"), "Ꭰ");
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/closer.rs b/third_party/rust/icu_casemap/src/closer.rs
@@ -0,0 +1,287 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::provider::{CaseMapUnfold, CaseMapUnfoldV1, CaseMapV1};
+use crate::set::ClosureSink;
+use crate::{CaseMapper, CaseMapperBorrowed};
+
+use icu_provider::prelude::*;
+
+/// A wrapper around [`CaseMapper`] that can produce case mapping closures
+/// over a character or string. This wrapper can be constructed directly, or
+/// by wrapping a reference to an existing [`CaseMapper`].
+///
+/// Most methods for this type live on [`CaseMapCloserBorrowed`], which you can obtain via
+/// [`CaseMapCloser::new()`] or [`CaseMapCloser::as_borrowed()`].
+///
+/// # Examples
+///
+/// ```rust
+/// use icu::casemap::CaseMapCloser;
+/// use icu::collections::codepointinvlist::CodePointInversionListBuilder;
+///
+/// let cm = CaseMapCloser::new();
+/// let mut builder = CodePointInversionListBuilder::new();
+/// let found = cm.add_string_case_closure_to("ffi", &mut builder);
+/// assert!(found);
+/// let set = builder.build();
+///
+/// assert!(set.contains('ﬃ'));
+///
+/// let mut builder = CodePointInversionListBuilder::new();
+/// let found = cm.add_string_case_closure_to("ss", &mut builder);
+/// assert!(found);
+/// let set = builder.build();
+///
+/// assert!(set.contains('ß'));
+/// assert!(set.contains('ẞ'));
+/// ```
+#[derive(Clone, Debug)]
+pub struct CaseMapCloser<CM> {
+    cm: CM,
+    unfold: DataPayload<CaseMapUnfoldV1>,
+}
+
+impl CaseMapCloser<CaseMapper> {
+    icu_provider::gen_buffer_data_constructors!(() -> error: DataError,
+    functions: [
+        new: skip,
+        try_new_with_buffer_provider,
+        try_new_unstable,
+        Self,
+    ]);
+
+    #[doc = icu_provider::gen_buffer_unstable_docs!(UNSTABLE, Self::new)]
+    pub fn try_new_unstable<P>(provider: &P) -> Result<Self, DataError>
+    where
+        P: DataProvider<CaseMapV1> + DataProvider<CaseMapUnfoldV1> + ?Sized,
+    {
+        let cm = CaseMapper::try_new_unstable(provider)?;
+        let unfold = provider.load(Default::default())?.payload;
+        Ok(Self { cm, unfold })
+    }
+}
+
+impl CaseMapCloser<CaseMapper> {
+    /// A constructor which creates a [`CaseMapCloserBorrowed`] using compiled data.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapCloser;
+    /// use icu::collections::codepointinvlist::CodePointInversionListBuilder;
+    ///
+    /// let cm = CaseMapCloser::new();
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// let found = cm.add_string_case_closure_to("ffi", &mut builder);
+    /// assert!(found);
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('ﬃ'));
+    ///
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// let found = cm.add_string_case_closure_to("ss", &mut builder);
+    /// assert!(found);
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('ß'));
+    /// assert!(set.contains('ẞ'));
+    /// ```
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    #[allow(clippy::new_ret_no_self)] // Intentional
+    pub const fn new() -> CaseMapCloserBorrowed<'static> {
+        CaseMapCloserBorrowed::new()
+    }
+}
+
+// We use Borrow, not AsRef, since we want the blanket impl on T
+impl<CM: AsRef<CaseMapper>> CaseMapCloser<CM> {
+    icu_provider::gen_buffer_data_constructors!((casemapper: CM) -> error: DataError,
+    functions: [
+        new_with_mapper: skip,
+        try_new_with_mapper_with_buffer_provider,
+        try_new_with_mapper_unstable,
+        Self,
+    ]);
+
+    /// A constructor which creates a [`CaseMapCloser`] from an existing [`CaseMapper`]
+    /// (either owned or as a reference)
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    pub const fn new_with_mapper(casemapper: CM) -> Self {
+        Self {
+            cm: casemapper,
+            unfold: DataPayload::from_static_ref(
+                crate::provider::Baked::SINGLETON_CASE_MAP_UNFOLD_V1,
+            ),
+        }
+    }
+
+    /// Construct this object to wrap an existing CaseMapper (or a reference to one), loading additional data as needed.
+    #[doc = icu_provider::gen_buffer_unstable_docs!(UNSTABLE, Self::new_with_mapper)]
+    pub fn try_new_with_mapper_unstable<P>(provider: &P, casemapper: CM) -> Result<Self, DataError>
+    where
+        P: DataProvider<CaseMapV1> + DataProvider<CaseMapUnfoldV1> + ?Sized,
+    {
+        let unfold = provider.load(Default::default())?.payload;
+        Ok(Self {
+            cm: casemapper,
+            unfold,
+        })
+    }
+
+    /// Constructs a borrowed version of this type for more efficient querying.
+    pub fn as_borrowed(&self) -> CaseMapCloserBorrowed<'_> {
+        CaseMapCloserBorrowed {
+            cm: self.cm.as_ref().as_borrowed(),
+            unfold: self.unfold.get(),
+        }
+    }
+}
+
+/// A borrowed [`CaseMapCloser`].
+///
+/// See methods or [`CaseMapCloser`] for examples.
+#[derive(Clone, Debug, Copy)]
+pub struct CaseMapCloserBorrowed<'a> {
+    cm: CaseMapperBorrowed<'a>,
+    unfold: &'a CaseMapUnfold<'a>,
+}
+
+impl CaseMapCloserBorrowed<'static> {
+    /// A constructor which creates a [`CaseMapCloserBorrowed`] using compiled data.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapCloser;
+    /// use icu::collections::codepointinvlist::CodePointInversionListBuilder;
+    ///
+    /// let cm = CaseMapCloser::new();
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// let found = cm.add_string_case_closure_to("ffi", &mut builder);
+    /// assert!(found);
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('ﬃ'));
+    ///
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// let found = cm.add_string_case_closure_to("ss", &mut builder);
+    /// assert!(found);
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('ß'));
+    /// assert!(set.contains('ẞ'));
+    /// ```
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    pub const fn new() -> CaseMapCloserBorrowed<'static> {
+        CaseMapCloserBorrowed {
+            cm: CaseMapper::new(),
+            unfold: crate::provider::Baked::SINGLETON_CASE_MAP_UNFOLD_V1,
+        }
+    }
+    /// Cheaply converts a [`CaseMapCloserBorrowed<'static>`] into a [`CaseMapCloser`].
+    ///
+    /// Note: Due to branching and indirection, using [`CaseMapCloser`] might inhibit some
+    /// compile-time optimizations that are possible with [`CaseMapCloserBorrowed`].
+    pub const fn static_to_owned(self) -> CaseMapCloser<CaseMapper> {
+        CaseMapCloser {
+            cm: self.cm.static_to_owned(),
+            unfold: DataPayload::from_static_ref(self.unfold),
+        }
+    }
+}
+
+#[cfg(feature = "compiled_data")]
+impl Default for CaseMapCloserBorrowed<'static> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CaseMapCloserBorrowed<'_> {
+    /// Adds all simple case mappings and the full case folding for `c` to `set`.
+    /// Also adds special case closure mappings.
+    ///
+    /// In other words, this adds all strings/characters that this casemaps to, as
+    /// well as all characters that may casemap to this one.
+    ///
+    /// The character itself is not added.
+    ///
+    /// For example, the mappings
+    /// - for s include long s
+    /// - for sharp s include ss
+    /// - for k include the Kelvin sign
+    ///
+    /// This function is identical to [`CaseMapperBorrowed::add_case_closure_to()`]; if you don't
+    /// need [`Self::add_string_case_closure_to()`] consider using a [`CaseMapper`] to avoid
+    /// loading additional data.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapCloser;
+    /// use icu::collections::codepointinvlist::CodePointInversionListBuilder;
+    ///
+    /// let cm = CaseMapCloser::new();
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// cm.add_case_closure_to('s', &mut builder);
+    ///
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('S'));
+    /// assert!(set.contains('ſ'));
+    /// assert!(!set.contains('s')); // does not contain itself
+    /// ```
+    pub fn add_case_closure_to<S: ClosureSink>(self, c: char, set: &mut S) {
+        self.cm.add_case_closure_to(c, set);
+    }
+
+    /// Finds all characters and strings which may casemap to `s` as their full case folding string
+    /// and adds them to the set. Includes the full case closure of each character mapping.
+    ///
+    /// In other words, this performs a reverse full case folding and then
+    /// adds the case closure items of the resulting code points.
+    ///
+    /// The string itself is not added to the set.
+    ///
+    /// Returns true if the string was found
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::CaseMapCloser;
+    /// use icu::collections::codepointinvlist::CodePointInversionListBuilder;
+    ///
+    /// let cm = CaseMapCloser::new();
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// let found = cm.add_string_case_closure_to("ffi", &mut builder);
+    /// assert!(found);
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('ﬃ'));
+    ///
+    /// let mut builder = CodePointInversionListBuilder::new();
+    /// let found = cm.add_string_case_closure_to("ss", &mut builder);
+    /// assert!(found);
+    /// let set = builder.build();
+    ///
+    /// assert!(set.contains('ß'));
+    /// assert!(set.contains('ẞ'));
+    /// ```
+    pub fn add_string_case_closure_to<S: ClosureSink>(self, s: &str, set: &mut S) -> bool {
+        self.cm.data.add_string_case_closure_to(s, set, self.unfold)
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/greek_to_me/data.rs b/third_party/rust/icu_casemap/src/greek_to_me/data.rs
@@ -0,0 +1,24 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+// This file is generated by running `cargo test --test gen_greek_to_me --features compiled_data,datagen
+//
+// Do not edit manually
+
+// All u8s in this file are PackedGreekPrecomposedLetterDatas, see parent module
+
+/// Data for characters in U+370-U+3FF
+pub(crate) const DATA_370: [u8; 0x90] = [128, 128, 128, 128, 0, 0, 128, 128, 0, 0, 128, 128, 128, 128, 0, 128, 0, 0, 0, 0, 0, 0, 65, 0, 66, 67, 68, 0, 69, 0, 70, 71, 100, 1, 128, 128, 128, 2, 128, 3, 128, 4, 128, 128, 128, 128, 128, 5, 128, 129, 0, 128, 128, 6, 128, 128, 128, 7, 36, 38, 65, 66, 67, 68, 102, 1, 128, 128, 128, 2, 128, 3, 128, 4, 128, 128, 128, 128, 128, 5, 128, 129, 128, 128, 128, 6, 128, 128, 128, 7, 36, 38, 69, 70, 71, 128, 128, 128, 8, 72, 40, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 129, 128, 128, 128, 2, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128];
+/// Data for characters in U+1F00-U+1FFF
+pub(crate) const DATA_1F00: [u8; 0xfd] = [1, 1, 65, 65, 65, 65, 65, 65, 1, 1, 65, 65, 65, 65, 65, 65, 2, 2, 66, 66, 66, 66, 0, 0, 2, 2, 66, 66, 66, 66, 0, 0, 3, 3, 67, 67, 67, 67, 67, 67, 3, 3, 67, 67, 67, 67, 67, 67, 4, 4, 68, 68, 68, 68, 68, 68, 4, 4, 68, 68, 68, 68, 68, 68, 5, 5, 69, 69, 69, 69, 0, 0, 5, 5, 69, 69, 69, 69, 0, 0, 6, 6, 70, 70, 70, 70, 70, 70, 0, 6, 0, 70, 0, 70, 0, 70, 7, 7, 71, 71, 71, 71, 71, 71, 7, 7, 71, 71, 71, 71, 71, 71, 65, 65, 66, 66, 67, 67, 68, 68, 69, 69, 70, 70, 71, 71, 0, 0, 17, 17, 81, 81, 81, 81, 81, 81, 17, 17, 81, 81, 81, 81, 81, 81, 19, 19, 83, 83, 83, 83, 83, 83, 19, 19, 83, 83, 83, 83, 83, 83, 23, 23, 87, 87, 87, 87, 87, 87, 23, 23, 87, 87, 87, 87, 87, 87, 1, 1, 81, 17, 81, 0, 65, 81, 1, 1, 65, 65, 17, 0, 4, 0, 0, 0, 83, 19, 83, 0, 67, 83, 66, 66, 67, 67, 19, 0, 0, 0, 4, 4, 100, 100, 0, 0, 68, 100, 4, 4, 68, 68, 0, 0, 0, 0, 6, 6, 102, 102, 129, 129, 70, 102, 6, 6, 70, 70, 129, 0, 0, 0, 0, 0, 87, 23, 87, 0, 71, 87, 69, 69, 71, 71, 23];
+
+/// Characters like the ohm sign that do not belong in the two blocks above
+pub(crate) fn match_extras(ch: char) -> Option<u8> {
+    Some(match ch {
+        'Ω' => 7,
+
+        _ => return None
+    })
+}
+
diff --git a/third_party/rust/icu_casemap/src/greek_to_me/mod.rs b/third_party/rust/icu_casemap/src/greek_to_me/mod.rs
@@ -0,0 +1,321 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! This module contains internal data handling tools for the special-cased Greek uppercasing
+//! code. The Greek uppercasing algorithm is code-driven, not user-data-driven, however the code
+//! relies on a CodePointTrie generated based on some Unicode rules.
+//!
+//! We try to keep most of the Greek-specific logic in here, though the actual logic to remove
+//! accents is in full_helper() as it must integrate with the control flow.
+//!
+//! This is public and doc(hidden) so that it can be accessed from the gen_greek_to_me test file,
+//! and should not be used otherwise.
+
+#[rustfmt::skip]
+mod data;
+
+pub(crate) fn get_data(ch: char) -> Option<GreekPrecomposedLetterData> {
+    let ch_i = ch as usize;
+    let packed = if (0x370..=0x3FF).contains(&ch_i) {
+        *data::DATA_370.get(ch_i - 0x370)?
+    } else if (0x1f00..0x1fff).contains(&ch_i) {
+        *data::DATA_1F00.get(ch_i - 0x1f00)?
+    } else {
+        data::match_extras(ch)?
+    };
+
+    let packed = PackedGreekPrecomposedLetterData(packed);
+
+    GreekPrecomposedLetterData::try_from(packed).ok()
+}
+
+/// A packed representation of [`GreekPrecomposedLetterData`]
+///
+/// Bit layout:
+///
+/// ```text
+///   7       6   5   4     3   2   1       0
+/// discr=0 | [diacritics]  | [vowel            ]  
+/// discr=1 | [  unused = 0     ]      | [is_rho]
+/// ```
+///
+/// Bit 7 is the discriminant. if 0, it is a vowel, else, it is a consonant.
+/// If the whole thing is a zero then it is assumed to be an empty entry.
+///
+/// In the vowel case, the next three bits are the next three elements of GreekDiacritics,
+/// in order (accented, dialytika, ypogegrammeni), and the four bits after that identify
+/// a GreekVowel value.
+///
+/// In the consonant case, the remaining seven bits identify a GreekConsonant value.
+#[derive(Debug, Clone, Copy)]
+pub struct PackedGreekPrecomposedLetterData(pub u8);
+
+impl TryFrom<PackedGreekPrecomposedLetterData> for GreekPrecomposedLetterData {
+    type Error = ();
+    fn try_from(other: PackedGreekPrecomposedLetterData) -> Result<GreekPrecomposedLetterData, ()> {
+        if other.0 == 0 {
+            return Err(());
+        }
+        if other.0 & 0x80 == 0 {
+            // vowel
+            let diacritics = GreekDiacritics {
+                accented: other.0 & 0x40 != 0,
+                dialytika: other.0 & 0x20 != 0,
+                ypogegrammeni: other.0 & 0x10 != 0,
+            };
+            let vowel = GreekVowel::try_from(other.0 & 0b1111);
+            debug_assert!(vowel.is_ok());
+            let vowel = vowel.unwrap_or(GreekVowel::Α);
+            Ok(GreekPrecomposedLetterData::Vowel(vowel, diacritics))
+        } else {
+            // consonant
+            // 0x80 is is_rho = false, 0x81 is is_rho = true
+            Ok(GreekPrecomposedLetterData::Consonant(other.0 == 0x81))
+        }
+    }
+}
+
+impl From<GreekPrecomposedLetterData> for PackedGreekPrecomposedLetterData {
+    fn from(other: GreekPrecomposedLetterData) -> Self {
+        match other {
+            GreekPrecomposedLetterData::Vowel(vowel, diacritics) => {
+                let mut bits = 0;
+                if diacritics.accented {
+                    bits |= 0x40;
+                }
+                if diacritics.dialytika {
+                    bits |= 0x20;
+                }
+                if diacritics.ypogegrammeni {
+                    bits |= 0x10;
+                }
+                bits |= vowel as u8;
+                PackedGreekPrecomposedLetterData(bits)
+            }
+            GreekPrecomposedLetterData::Consonant(is_rho) => {
+                PackedGreekPrecomposedLetterData(0x80 + is_rho as u8)
+            }
+        }
+    }
+}
+
+/// The precomposed letter data stored in the hardcoded data in `mod data`
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum GreekPrecomposedLetterData {
+    /// A vowel, with a capitalized base letter, and the diacritics found
+    Vowel(GreekVowel, GreekDiacritics),
+    /// A consonant or vowel that does not take diacritics
+    ///
+    /// The boolean is true when the consonant is a rho, which is handled specially since
+    /// it can take breathing marks (but is *not* a vowel)
+    Consonant(bool),
+}
+
+/// n.b. these are Greek capital letters, not Latin
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
+pub enum GreekVowel {
+    // 0 is purposely left out so that the all-zero case is unambiguous
+    Α = 1,
+    Ε = 2,
+    Η = 3,
+    Ι = 4,
+    Ο = 5,
+    Υ = 6,
+    Ω = 7,
+    ϒ = 8,
+}
+pub const CAPITAL_RHO: char = 'Ρ';
+
+impl From<GreekVowel> for char {
+    fn from(other: GreekVowel) -> Self {
+        match other {
+            GreekVowel::Α => 'Α',
+            GreekVowel::Ε => 'Ε',
+            GreekVowel::Η => 'Η',
+            GreekVowel::Ι => 'Ι',
+            GreekVowel::Ο => 'Ο',
+            GreekVowel::Υ => 'Υ',
+            GreekVowel::Ω => 'Ω',
+            GreekVowel::ϒ => 'ϒ',
+        }
+    }
+}
+
+impl TryFrom<char> for GreekVowel {
+    type Error = ();
+    fn try_from(other: char) -> Result<Self, ()> {
+        Ok(match other {
+            'Α' => GreekVowel::Α,
+            'Ε' => GreekVowel::Ε,
+            'Η' => GreekVowel::Η,
+            'Ι' => GreekVowel::Ι,
+            'Ο' => GreekVowel::Ο,
+            'Υ' => GreekVowel::Υ,
+            'Ω' => GreekVowel::Ω,
+            'ϒ' => GreekVowel::ϒ,
+            _ => return Err(()),
+        })
+    }
+}
+
+impl TryFrom<u8> for GreekVowel {
+    type Error = ();
+    fn try_from(other: u8) -> Result<Self, ()> {
+        Ok(match other {
+            1 => Self::Α,
+            2 => Self::Ε,
+            3 => Self::Η,
+            4 => Self::Ι,
+            5 => Self::Ο,
+            6 => Self::Υ,
+            7 => Self::Ω,
+            8 => Self::ϒ,
+            _ => return Err(()),
+        })
+    }
+}
+
+/// General diacritic information about a character or combining character sequence.
+#[derive(Copy, Clone, Default, PartialEq, Eq, Debug)]
+pub struct GreekDiacritics {
+    /// Whether it has an accent.
+    pub accented: bool,
+    /// Whether it has a dialytika.
+    pub dialytika: bool,
+    /// Whether it has a ypogegrammeni.
+    pub ypogegrammeni: bool,
+}
+
+/// General diacritic information about a combining character sequence,
+/// identifying the source of the diacritics.
+#[derive(Copy, Clone, Default, PartialEq, Eq, Debug)]
+pub struct GreekCombiningCharacterSequenceDiacritics {
+    // Diacritics precomposed on the base.
+    pub precomposed: GreekDiacritics,
+    // Combining diacritics.
+    pub combining: GreekDiacritics,
+}
+
+pub const TONOS: char = '\u{0301}';
+pub const DIALYTIKA: char = '\u{0308}';
+pub const DIALYTIKA_TONOS: char = '\u{0344}';
+pub const YPOGEGRAMMENI: char = '\u{0345}';
+
+#[macro_export]
+#[doc(hidden)] // macro
+macro_rules! diacritics {
+    // Accents.
+    // These are mostly removed when uppercasing, but their presence may require
+    // adding a διαλυτικά to a following vowel.
+    (ACCENTS) => {
+        // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%5Cu0300+%5Cu0301+%5Cu0342+%5Cu0302+%5Cu0303+%5Cu0311%5D&g=&i=
+        '\u{0300}' // Polytonic βαρεία (varia), grave accent.
+        | $crate::greek_to_me::TONOS // Polytonic οξεία (oxia) unified with monotonic τόνος (tonos), acute accent.
+        | '\u{0342}' // Polytonic περισπωμένη (perispomeni), often translated to circumflex.
+        | '\u{0302}' // Circumflex accent, sometimes a lookalike of the περισπωμένη.
+        | '\u{0303}' // Tilde, sometimes a lookalike of the περισπωμένη.
+        | '\u{0311}' // Inverted breve, sometimes a lookalike of the περισπωμένη.
+    };
+    // Breathings and length marks.
+    // These expected to occur in Greek combining sequences, and are removed when uppercasing.
+    // This removal has no other effect.
+    (BREATHING_AND_LENGTH) => {
+        // https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%5Cu0304+%5Cu0306+%5Cu0313+%5Cu0314+%5Cu0343%5D&g=&i=
+        '\u{0304}'  // Macron, marking long vowels.
+        | '\u{0306}'  // Breve, marking short vowels.
+        | '\u{0313}'  // Comma above, smooth breathing or κορωνίς marking crasis.
+        | '\u{0314}'  // Reversed comma above, rough breathing.
+        | '\u{0343}'  // κορωνίς (koronis), canonically decomposes to comma above.
+    };
+    // All diacritics containing a dialytika
+    (DIALYTIKA_ALL) => { $crate::greek_to_me::DIALYTIKA | $crate::greek_to_me::DIALYTIKA_TONOS };
+    (DIALYTIKA) => { $crate::greek_to_me::DIALYTIKA };
+    (DIALYTIKA_TONOS) => { $crate::greek_to_me::DIALYTIKA_TONOS };
+    (YPOGEGRAMMENI) => { $crate::greek_to_me::YPOGEGRAMMENI };
+    ($($i:ident)|+) => { $(diacritics!($i))|+};
+}
+
+/// Macro that generates match arms for various diacritic groupings.
+///
+/// Groupings supported:
+///
+/// - ACCENTS
+/// - BREATHING_AND_LENGTH
+/// - DIALYTIKA, DIALYTIKA_TONOS, and DIALITYKA_ALL
+/// - YPOGEGRAMMENI
+///
+/// This is a macro to make it easy to keep the lists of accents in sync.
+pub use crate::diacritics;
+
+impl GreekDiacritics {
+    /// Whilst forwards-iterating from an existing character,
+    /// consume all further greek diacritics and store their existence into this struct.
+    pub(crate) fn consume_greek_diacritics(&mut self, context_after: &str) {
+        for c in context_after.chars() {
+            match c {
+                diacritics!(ACCENTS) => self.accented = true,
+                DIALYTIKA_TONOS => {
+                    self.dialytika = true;
+                    self.accented = true;
+                }
+                DIALYTIKA => self.dialytika = true,
+                YPOGEGRAMMENI => self.ypogegrammeni = true,
+                // Ignore other accent marks that are expected to co-occur with Greek.
+                diacritics!(BREATHING_AND_LENGTH) => (),
+                _ => break,
+            }
+        }
+    }
+}
+
+/// Given the context before a character, check if it is preceded by a Greek letter.
+pub(crate) fn preceded_by_greek_letter(context_before: &str) -> bool {
+    for c in context_before.chars().rev() {
+        match c {
+            diacritics!(ACCENTS | BREATHING_AND_LENGTH | DIALYTIKA_ALL | YPOGEGRAMMENI) => continue,
+            _ => return get_data(c).is_some(),
+        }
+    }
+    false
+}
+
+/// Returns diacritic information for the combining character sequence preceding the current character
+/// if it that preceding combining character sequence is a greek vowel.
+pub(crate) fn preceding_greek_vowel_diacritics(
+    context_before: &str,
+) -> Option<GreekCombiningCharacterSequenceDiacritics> {
+    let mut combining: GreekDiacritics = Default::default();
+    for c in context_before.chars().rev() {
+        match c {
+            diacritics!(ACCENTS) => combining.accented = true,
+            diacritics!(DIALYTIKA_TONOS) => {
+                combining.dialytika = true;
+                combining.accented = true;
+            }
+            diacritics!(DIALYTIKA) => combining.dialytika = true,
+            diacritics!(BREATHING_AND_LENGTH) => continue,
+            _ => {
+                let data = get_data(c);
+                if let Some(GreekPrecomposedLetterData::Vowel(_vowel, diacritics)) = data {
+                    return Some(GreekCombiningCharacterSequenceDiacritics {
+                        precomposed: diacritics,
+                        combining,
+                    });
+                } else {
+                    // Not a greek vowel.
+                    return None;
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Is the character a diacritic expected to be used with greek (except ypogegrammeni).
+pub(crate) fn is_greek_diacritic_except_ypogegrammeni(c: char) -> bool {
+    matches!(
+        c,
+        diacritics!(ACCENTS | BREATHING_AND_LENGTH | DIALYTIKA_ALL)
+    )
+}
diff --git a/third_party/rust/icu_casemap/src/internals.rs b/third_party/rust/icu_casemap/src/internals.rs
@@ -0,0 +1,865 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! This module contains most of the actual algorithms for case mapping.
+//!
+//! Primarily, it implements methods on `CaseMap`, which contains the data model.
+
+use crate::greek_to_me::{
+    self, GreekCombiningCharacterSequenceDiacritics, GreekDiacritics, GreekPrecomposedLetterData,
+    GreekVowel,
+};
+use crate::provider::data::{DotType, MappingKind};
+use crate::provider::exception_helpers::ExceptionSlot;
+use crate::provider::{CaseMap, CaseMapUnfold};
+use crate::set::ClosureSink;
+use crate::titlecase::TrailingCase;
+use core::fmt;
+use icu_locale_core::LanguageIdentifier;
+use writeable::Writeable;
+
+const ACUTE: char = '\u{301}';
+
+// Used to control the behavior of CaseMapper::fold.
+// Currently only used to decide whether to use Turkic (T) mappings for dotted/dotless i.
+#[derive(Copy, Clone, Default)]
+pub(crate) struct FoldOptions {
+    exclude_special_i: bool,
+}
+
+impl FoldOptions {
+    pub fn with_turkic_mappings() -> Self {
+        Self {
+            exclude_special_i: true,
+        }
+    }
+}
+
+/// Helper type that wraps a writeable in a prefix string
+pub(crate) struct StringAndWriteable<'a, W> {
+    pub string: &'a str,
+    pub writeable: W,
+}
+
+impl<Wr: Writeable> Writeable for StringAndWriteable<'_, Wr> {
+    fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {
+        sink.write_str(self.string)?;
+        self.writeable.write_to(sink)
+    }
+    fn writeable_length_hint(&self) -> writeable::LengthHint {
+        writeable::LengthHint::exact(self.string.len()) + self.writeable.writeable_length_hint()
+    }
+}
+
+pub(crate) struct FullCaseWriteable<'a, 'data, const IS_TITLE_CONTEXT: bool> {
+    data: &'data CaseMap<'data>,
+    src: &'a str,
+    locale: CaseMapLocale,
+    mapping: MappingKind,
+    titlecase_tail_casing: TrailingCase,
+}
+
+impl<'a, const IS_TITLE_CONTEXT: bool> Writeable for FullCaseWriteable<'a, '_, IS_TITLE_CONTEXT> {
+    #[allow(clippy::indexing_slicing)] // last_uncopied_index and i are known to be in bounds
+    fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {
+        let src = self.src;
+        let mut mapping = self.mapping;
+        let mut iter = src.char_indices();
+        for (i, c) in &mut iter {
+            let context = ContextIterator::new(&src[..i], &src[i..]);
+            self.data
+                .full_helper::<IS_TITLE_CONTEXT, W>(c, context, self.locale, mapping, sink)?;
+            if IS_TITLE_CONTEXT {
+                if self.titlecase_tail_casing == TrailingCase::Lower {
+                    mapping = MappingKind::Lower;
+                } else {
+                    break;
+                }
+            }
+        }
+        // Write the rest of the string
+        if IS_TITLE_CONTEXT && self.titlecase_tail_casing == TrailingCase::Unchanged {
+            sink.write_str(iter.as_str())?;
+        }
+        Ok(())
+    }
+    fn writeable_length_hint(&self) -> writeable::LengthHint {
+        writeable::LengthHint::at_least(self.src.len())
+    }
+    fn write_to_string(&self) -> alloc::borrow::Cow<'a, str> {
+        writeable::to_string_or_borrow(self, self.src.as_bytes())
+    }
+}
+
+impl<'data> CaseMap<'data> {
+    fn simple_helper(&self, c: char, kind: MappingKind) -> char {
+        let data = self.lookup_data(c);
+        if !data.has_exception() {
+            if data.is_relevant_to(kind) {
+                let folded = c as i32 + data.delta() as i32;
+                // GIGO: delta should be valid
+                char::from_u32(folded as u32).unwrap_or(c)
+            } else {
+                c
+            }
+        } else {
+            let idx = data.exception_index();
+            let exception = self.exceptions.get(idx);
+            if data.is_relevant_to(kind) {
+                if let Some(simple) = exception.get_simple_case_slot_for(c) {
+                    return simple;
+                }
+            }
+            exception.slot_char_for_kind(kind).unwrap_or(c)
+        }
+    }
+
+    // Returns the lowercase mapping of the given `char`.
+    #[inline]
+    pub(crate) fn simple_lower(&self, c: char) -> char {
+        self.simple_helper(c, MappingKind::Lower)
+    }
+
+    // Returns the uppercase mapping of the given `char`.
+    #[inline]
+    pub(crate) fn simple_upper(&self, c: char) -> char {
+        self.simple_helper(c, MappingKind::Upper)
+    }
+
+    // Returns the titlecase mapping of the given `char`.
+    #[inline]
+    pub(crate) fn simple_title(&self, c: char) -> char {
+        self.simple_helper(c, MappingKind::Title)
+    }
+
+    // Return the simple case folding mapping of the given char.
+    #[inline]
+    pub(crate) fn simple_fold(&self, c: char, options: FoldOptions) -> char {
+        let data = self.lookup_data(c);
+        if !data.has_exception() {
+            if data.is_upper_or_title() {
+                let folded = c as i32 + data.delta() as i32;
+                // GIGO: delta should be valid
+                char::from_u32(folded as u32).unwrap_or(c)
+            } else {
+                c
+            }
+        } else {
+            // TODO: if we move conditional fold and no_simple_case_folding into
+            // simple_helper, this function can just call simple_helper.
+            let idx = data.exception_index();
+            let exception = self.exceptions.get(idx);
+            if exception.bits.has_conditional_fold() {
+                self.simple_fold_special_case(c, options)
+            } else if exception.bits.no_simple_case_folding() {
+                c
+            } else if data.is_upper_or_title() && exception.has_slot(ExceptionSlot::Delta) {
+                // unwrap_or case should never happen but best to avoid panics
+                exception.get_simple_case_slot_for(c).unwrap_or('\0')
+            } else if let Some(slot_char) = exception.slot_char_for_kind(MappingKind::Fold) {
+                slot_char
+            } else {
+                c
+            }
+        }
+    }
+
+    fn dot_type(&self, c: char) -> DotType {
+        let data = self.lookup_data(c);
+        if !data.has_exception() {
+            data.dot_type()
+        } else {
+            let idx = data.exception_index();
+            self.exceptions.get(idx).bits.dot_type()
+        }
+    }
+
+    // Returns true if this code point is is case-sensitive.
+    // This is not currently exposed.
+    #[allow(dead_code)]
+    fn is_case_sensitive(&self, c: char) -> bool {
+        let data = self.lookup_data(c);
+        if !data.has_exception() {
+            data.is_sensitive()
+        } else {
+            let idx = data.exception_index();
+            self.exceptions.get(idx).bits.is_sensitive()
+        }
+    }
+
+    /// Returns whether the character is cased
+    pub(crate) fn is_cased(&self, c: char) -> bool {
+        self.lookup_data(c).case_type().is_some()
+    }
+
+    #[inline(always)]
+    // IS_TITLE_CONTEXT must be true if kind is MappingKind::Title
+    // The kind may be a different kind with IS_TITLE_CONTEXT still true because
+    // titlecasing a segment involves switching to lowercase later
+    fn full_helper<const IS_TITLE_CONTEXT: bool, W: fmt::Write + ?Sized>(
+        &self,
+        c: char,
+        context: ContextIterator,
+        locale: CaseMapLocale,
+        kind: MappingKind,
+        sink: &mut W,
+    ) -> fmt::Result {
+        // If using a title mapping IS_TITLE_CONTEXT must be true
+        debug_assert!(kind != MappingKind::Title || IS_TITLE_CONTEXT);
+        // In a title context, kind MUST be Title or Lower
+        debug_assert!(
+            !IS_TITLE_CONTEXT || kind == MappingKind::Title || kind == MappingKind::Lower
+        );
+
+        // ICU4C's non-standard extension for Dutch IJ titlecasing
+        // handled here instead of in full_lower_special_case because J does not have conditional
+        // special casemapping.
+        if IS_TITLE_CONTEXT && locale == CaseMapLocale::Dutch && kind == MappingKind::Lower {
+            // When titlecasing, a J found immediately after an I at the beginning of the segment
+            // should also uppercase. They are both allowed to have an acute accent but it must
+            // be present on both letters or neither. They may not have any other combining marks.
+            if (c == 'j' || c == 'J') && context.is_dutch_ij_pair_at_beginning(self) {
+                return sink.write_char('J');
+            }
+        }
+
+        // ICU4C's non-standard extension for Greek uppercasing:
+        // https://icu.unicode.org/design/case/greek-upper.
+        // Effectively removes Greek accents from Greek vowels during uppercasing,
+        // whilst attempting to preserve additional marks like the dialytika (diæresis)
+        // and ypogegrammeni (combining small iota).
+        if !IS_TITLE_CONTEXT && locale == CaseMapLocale::Greek && kind == MappingKind::Upper {
+            // Remove all combining diacritics on a Greek letter.
+            // Ypogegrammeni is not an accent mark and is handled by regular casemapping (it turns into
+            // a capital iota).
+            // The dialytika is removed here, but it may be added again when the base letter is being processed.
+            if greek_to_me::is_greek_diacritic_except_ypogegrammeni(c)
+                && context.preceded_by_greek_letter()
+            {
+                return Ok(());
+            }
+            let data = greek_to_me::get_data(c);
+            // Check if the character is a Greek vowel
+            match data {
+                Some(GreekPrecomposedLetterData::Vowel(vowel, mut precomposed_diacritics)) => {
+                    // Get the diacritics on the character itself, and add any further combining diacritics
+                    // from the context.
+                    let mut diacritics = context.add_greek_diacritics(precomposed_diacritics);
+                    // If the previous vowel had an accent (which would be removed) but no dialytika,
+                    // and this is an iota or upsilon, add a dialytika since it is necessary to disambiguate
+                    // the now-unaccented adjacent vowels from a digraph/diphthong.
+                    // Use a precomposed dialytika if the accent was precomposed, and a combining dialytika
+                    // if the accent was combining, so as to map NFD to NFD and NFC to NFC.
+                    if !diacritics.dialytika && (vowel == GreekVowel::Ι || vowel == GreekVowel::Υ)
+                    {
+                        if let Some(preceding_vowel) = context.preceding_greek_vowel_diacritics() {
+                            if !preceding_vowel.combining.dialytika
+                                && !preceding_vowel.precomposed.dialytika
+                            {
+                                if preceding_vowel.combining.accented {
+                                    diacritics.dialytika = true;
+                                } else {
+                                    precomposed_diacritics.dialytika =
+                                        preceding_vowel.precomposed.accented;
+                                }
+                            }
+                        }
+                    }
+                    // Write the base of the uppercased combining character sequence.
+                    // In most branches this is [`upper_base`], i.e., the uppercase letter with all accents removed.
+                    // In some branches the base has a precomposed diacritic.
+                    // In the case of the Greek disjunctive "or", a combining tonos may also be written.
+                    match vowel {
+                        GreekVowel::Η => {
+                            // The letter η (eta) is allowed to retain a tonos when it is form a single-letter word to distinguish
+                            // the feminine definite article ἡ (monotonic η) from the disjunctive "or" ἤ (monotonic ή).
+                            //
+                            // A lone η with an accent other than the oxia/tonos is not expected,
+                            // so there is no need to special-case the oxia/tonos.
+                            // The ancient ᾖ (exist.PRS.SUBJ.3s) has a iota subscript as well as the circumflex,
+                            // so it would not be given an oxia/tonos under this rule, and the subjunctive is formed with a particle
+                            // (e.g. να είναι) since Byzantine times anyway.
+                            if diacritics.accented
+                                && !context.followed_by_cased_letter(self)
+                                && !context.preceded_by_cased_letter(self)
+                                && !diacritics.ypogegrammeni
+                            {
+                                if precomposed_diacritics.accented {
+                                    sink.write_char('Ή')?;
+                                } else {
+                                    sink.write_char('Η')?;
+                                    sink.write_char(greek_to_me::TONOS)?;
+                                }
+                            } else {
+                                sink.write_char('Η')?;
+                            }
+                        }
+                        GreekVowel::Ι => sink.write_char(if precomposed_diacritics.dialytika {
+                            diacritics.dialytika = false;
+                            'Ϊ'
+                        } else {
+                            vowel.into()
+                        })?,
+                        GreekVowel::Υ => sink.write_char(if precomposed_diacritics.dialytika {
+                            diacritics.dialytika = false;
+                            'Ϋ'
+                        } else {
+                            vowel.into()
+                        })?,
+                        _ => sink.write_char(vowel.into())?,
+                    };
+                    if diacritics.dialytika {
+                        sink.write_char(greek_to_me::DIALYTIKA)?;
+                    }
+                    if precomposed_diacritics.ypogegrammeni {
+                        sink.write_char('Ι')?;
+                    }
+
+                    return Ok(());
+                }
+                // Rho might have breathing marks, we handle it specially
+                // to remove them
+                Some(GreekPrecomposedLetterData::Consonant(true)) => {
+                    sink.write_char(greek_to_me::CAPITAL_RHO)?;
+                    return Ok(());
+                }
+                _ => (),
+            }
+        }
+
+        let data = self.lookup_data(c);
+        if !data.has_exception() {
+            if data.is_relevant_to(kind) {
+                let mapped = c as i32 + data.delta() as i32;
+                // GIGO: delta should be valid
+                let mapped = char::from_u32(mapped as u32).unwrap_or(c);
+                sink.write_char(mapped)
+            } else {
+                sink.write_char(c)
+            }
+        } else {
+            let idx = data.exception_index();
+            let exception = self.exceptions.get(idx);
+            if exception.bits.has_conditional_special() {
+                if let Some(special) = match kind {
+                    MappingKind::Lower => {
+                        self.full_lower_special_case::<IS_TITLE_CONTEXT>(c, context, locale)
+                    }
+                    MappingKind::Fold => self.full_fold_special_case(c, context, locale),
+                    MappingKind::Upper | MappingKind::Title => self
+                        .full_upper_or_title_special_case::<IS_TITLE_CONTEXT>(c, context, locale),
+                } {
+                    return special.write_to(sink);
+                }
+            }
+            if let Some(mapped_string) = exception.get_fullmappings_slot_for_kind(kind) {
+                if !mapped_string.is_empty() {
+                    return sink.write_str(mapped_string);
+                }
+            }
+
+            if kind == MappingKind::Fold && exception.bits.no_simple_case_folding() {
+                return sink.write_char(c);
+            }
+
+            if data.is_relevant_to(kind) {
+                if let Some(simple) = exception.get_simple_case_slot_for(c) {
+                    return sink.write_char(simple);
+                }
+            }
+
+            if let Some(slot_char) = exception.slot_char_for_kind(kind) {
+                sink.write_char(slot_char)
+            } else {
+                sink.write_char(c)
+            }
+        }
+    }
+
+    // These constants are used for hardcoded locale-specific foldings.
+    const I_DOT: &'static str = "\u{69}\u{307}";
+    const J_DOT: &'static str = "\u{6a}\u{307}";
+    const I_OGONEK_DOT: &'static str = "\u{12f}\u{307}";
+    const I_DOT_GRAVE: &'static str = "\u{69}\u{307}\u{300}";
+    const I_DOT_ACUTE: &'static str = "\u{69}\u{307}\u{301}";
+    const I_DOT_TILDE: &'static str = "\u{69}\u{307}\u{303}";
+
+    // Special case folding mappings, hardcoded.
+    // This handles the special Turkic mappings for uppercase I and dotted uppercase I
+    // For non-Turkic languages, this mapping is normally not used.
+    // For Turkic languages (tr, az), this mapping can be used instead of the normal mapping for these characters.
+    fn simple_fold_special_case(&self, c: char, options: FoldOptions) -> char {
+        debug_assert!(c == '\u{49}' || c == '\u{130}');
+        let is_turkic = options.exclude_special_i;
+        match (c, is_turkic) {
+            // Turkic mappings
+            ('\u{49}', true) => '\u{131}', // 0049; T; 0131; # LATIN CAPITAL LETTER I
+            ('\u{130}', true) => '\u{69}', /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
+
+            // Default mappings
+            ('\u{49}', false) => '\u{69}', // 0049; C; 0069; # LATIN CAPITAL LETTER I
+
+            // There is no simple case folding for U+130.
+            (c, _) => c,
+        }
+    }
+
+    fn full_lower_special_case<const IS_TITLE_CONTEXT: bool>(
+        &self,
+        c: char,
+        context: ContextIterator,
+        locale: CaseMapLocale,
+    ) -> Option<FullMappingResult> {
+        if locale == CaseMapLocale::Lithuanian {
+            // Lithuanian retains the dot in a lowercase i when followed by accents.
+            // Introduce an explicit dot above when lowercasing capital I's and J's
+            // whenever there are more accents above (of the accents used in
+            // Lithuanian: grave, acute, and tilde above).
+
+            // Check for accents above I, J, and I-with-ogonek.
+            if c == 'I' && context.followed_by_more_above(self) {
+                return Some(FullMappingResult::String(Self::I_DOT));
+            } else if c == 'J' && context.followed_by_more_above(self) {
+                return Some(FullMappingResult::String(Self::J_DOT));
+            } else if c == '\u{12e}' && context.followed_by_more_above(self) {
+                return Some(FullMappingResult::String(Self::I_OGONEK_DOT));
+            }
+
+            // These characters are precomposed with accents above, so we don't
+            // have to look at the context.
+            if c == '\u{cc}' {
+                return Some(FullMappingResult::String(Self::I_DOT_GRAVE));
+            } else if c == '\u{cd}' {
+                return Some(FullMappingResult::String(Self::I_DOT_ACUTE));
+            } else if c == '\u{128}' {
+                return Some(FullMappingResult::String(Self::I_DOT_TILDE));
+            }
+        }
+
+        if locale == CaseMapLocale::Turkish {
+            if c == '\u{130}' {
+                // I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
+                return Some(FullMappingResult::CodePoint('i'));
+            } else if c == '\u{307}' && context.preceded_by_capital_i::<IS_TITLE_CONTEXT>(self) {
+                // When lowercasing, remove dot_above in the sequence I + dot_above,
+                // which will turn into i. This matches the behaviour of the
+                // canonically equivalent I-dot_above.
+                //
+                // In a titlecase context, we do not want to apply this behavior to cases where the I
+                // was at the beginning of the string, as that I and its marks should be handled by the
+                // uppercasing rules (which ignore it, see below)
+
+                return Some(FullMappingResult::Remove);
+            } else if c == 'I' && !context.followed_by_dot_above(self) {
+                // When lowercasing, unless an I is before a dot_above, it turns
+                // into a dotless i.
+                return Some(FullMappingResult::CodePoint('\u{131}'));
+            }
+        }
+
+        if c == '\u{130}' {
+            // Preserve canonical equivalence for I with dot. Turkic is handled above.
+            return Some(FullMappingResult::String(Self::I_DOT));
+        }
+
+        if c == '\u{3a3}'
+            && context.preceded_by_cased_letter(self)
+            && !context.followed_by_cased_letter(self)
+        {
+            // Greek capital sigman maps depending on surrounding cased letters.
+            return Some(FullMappingResult::CodePoint('\u{3c2}'));
+        }
+
+        // No relevant special case mapping. Use a normal mapping.
+        None
+    }
+
+    fn full_upper_or_title_special_case<const IS_TITLE_CONTEXT: bool>(
+        &self,
+        c: char,
+        context: ContextIterator,
+        locale: CaseMapLocale,
+    ) -> Option<FullMappingResult> {
+        if locale == CaseMapLocale::Turkish && c == 'i' {
+            // In Turkic languages, i turns into a dotted capital I.
+            return Some(FullMappingResult::CodePoint('\u{130}'));
+        }
+        if locale == CaseMapLocale::Lithuanian
+            && c == '\u{307}'
+            && context.preceded_by_soft_dotted(self)
+        {
+            // Lithuanian retains the dot in a lowercase i when followed by accents.
+            // Remove dot_above after i with upper or titlecase.
+            return Some(FullMappingResult::Remove);
+        }
+        // ICU4C's non-standard extension for Armenian ligature ech-yiwn.
+        if c == '\u{587}' {
+            return match (locale, IS_TITLE_CONTEXT) {
+                (CaseMapLocale::Armenian, false) => Some(FullMappingResult::String("ԵՎ")),
+                (CaseMapLocale::Armenian, true) => Some(FullMappingResult::String("Եվ")),
+                (_, false) => Some(FullMappingResult::String("ԵՒ")),
+                (_, true) => Some(FullMappingResult::String("Եւ")),
+            };
+        }
+        None
+    }
+
+    fn full_fold_special_case(
+        &self,
+        c: char,
+        _context: ContextIterator,
+        locale: CaseMapLocale,
+    ) -> Option<FullMappingResult> {
+        let is_turkic = locale == CaseMapLocale::Turkish;
+        match (c, is_turkic) {
+            // Turkic mappings
+            ('\u{49}', true) => Some(FullMappingResult::CodePoint('\u{131}')),
+            ('\u{130}', true) => Some(FullMappingResult::CodePoint('\u{69}')),
+
+            // Default mappings
+            ('\u{49}', false) => Some(FullMappingResult::CodePoint('\u{69}')),
+            ('\u{130}', false) => Some(FullMappingResult::String(Self::I_DOT)),
+            (_, _) => None,
+        }
+    }
+    /// IS_TITLE_CONTEXT is true iff the mapping is MappingKind::Title, primarily exists
+    /// to avoid perf impacts on other more common modes of operation
+    ///
+    /// titlecase_tail_casing is only read in IS_TITLE_CONTEXT
+    pub(crate) fn full_helper_writeable<'a: 'data, const IS_TITLE_CONTEXT: bool>(
+        &'data self,
+        src: &'a str,
+        locale: CaseMapLocale,
+        mapping: MappingKind,
+        titlecase_tail_casing: TrailingCase,
+    ) -> FullCaseWriteable<'a, 'data, IS_TITLE_CONTEXT> {
+        // Ensure that they are either both true or both false
+        debug_assert!(IS_TITLE_CONTEXT == (mapping == MappingKind::Title));
+
+        FullCaseWriteable::<IS_TITLE_CONTEXT> {
+            data: self,
+            src,
+            locale,
+            mapping,
+            titlecase_tail_casing,
+        }
+    }
+
+    /// Adds all simple case mappings and the full case folding for `c` to `set`.
+    /// Also adds special case closure mappings.
+    /// The character itself is not added.
+    /// For example, the mappings
+    /// - for s include long s
+    /// - for sharp s include ss
+    /// - for k include the Kelvin sign
+    pub(crate) fn add_case_closure_to<S: ClosureSink>(&self, c: char, set: &mut S) {
+        // Hardcode the case closure of i and its relatives and ignore the
+        // data file data for these characters.
+        // The Turkic dotless i and dotted I with their case mapping conditions
+        // and case folding option make the related characters behave specially.
+        // This code matches their closure behavior to their case folding behavior.
+        match c {
+            // Regular i and I are in one equivalence class.
+            '\u{49}' => {
+                set.add_char('\u{69}');
+                return;
+            }
+            '\u{69}' => {
+                set.add_char('\u{49}');
+                return;
+            }
+
+            // Dotted I is in a class with <0069 0307> (for canonical equivalence with <0049 0307>)
+            '\u{130}' => {
+                set.add_string(Self::I_DOT);
+                return;
+            }
+
+            // Dotless i is in a class by itself
+            '\u{131}' => {
+                return;
+            }
+
+            _ => {}
+        }
+
+        let data = self.lookup_data(c);
+        if !data.has_exception() {
+            if data.case_type().is_some() {
+                let delta = data.delta() as i32;
+                if delta != 0 {
+                    // Add the one simple case mapping, no matter what type it is.
+                    let codepoint = c as i32 + delta;
+                    // GIGO: delta should be valid
+                    let mapped = char::from_u32(codepoint as u32).unwrap_or(c);
+                    set.add_char(mapped);
+                }
+            }
+            return;
+        }
+
+        // c has exceptions, so there may be multiple simple and/or full case mappings.
+        let idx = data.exception_index();
+        let exception = self.exceptions.get(idx);
+
+        // Add all simple case mappings.
+        for slot in [
+            ExceptionSlot::Lower,
+            ExceptionSlot::Fold,
+            ExceptionSlot::Upper,
+            ExceptionSlot::Title,
+        ] {
+            if let Some(simple) = exception.get_char_slot(slot) {
+                set.add_char(simple);
+            }
+        }
+        if let Some(simple) = exception.get_simple_case_slot_for(c) {
+            set.add_char(simple);
+        }
+
+        exception.add_full_and_closure_mappings(set);
+    }
+
+    /// Maps the string to single code points and adds the associated case closure
+    /// mappings.
+    ///
+    /// (see docs on CaseMapper::add_string_case_closure_to)
+    pub(crate) fn add_string_case_closure_to<S: ClosureSink>(
+        &self,
+        s: &str,
+        set: &mut S,
+        unfold_data: &CaseMapUnfold,
+    ) -> bool {
+        if s.chars().count() <= 1 {
+            // The string is too short to find any match.
+            return false;
+        }
+        match unfold_data.get(s) {
+            Some(closure_string) => {
+                for c in closure_string.chars() {
+                    set.add_char(c);
+                    self.add_case_closure_to(c, set);
+                }
+                true
+            }
+            None => false,
+        }
+    }
+}
+
+// An internal representation of locale. Non-Root values of this
+// enumeration imply that hard-coded special cases exist for this
+// language.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum CaseMapLocale {
+    Root,
+    Turkish,
+    Lithuanian,
+    Greek,
+    Dutch,
+    Armenian,
+}
+
+impl CaseMapLocale {
+    pub const fn from_langid(langid: &LanguageIdentifier) -> Self {
+        use icu_locale_core::subtags::{language, Language};
+        const TR: Language = language!("tr");
+        const AZ: Language = language!("az");
+        const LT: Language = language!("lt");
+        const EL: Language = language!("el");
+        const NL: Language = language!("nl");
+        const HY: Language = language!("hy");
+        match langid.language {
+            TR | AZ => Self::Turkish,
+            LT => Self::Lithuanian,
+            EL => Self::Greek,
+            NL => Self::Dutch,
+            HY => Self::Armenian,
+            _ => Self::Root,
+        }
+    }
+}
+
+pub enum FullMappingResult<'a> {
+    Remove,
+    CodePoint(char),
+    String(&'a str),
+}
+
+impl FullMappingResult<'_> {
+    #[allow(dead_code)]
+    fn add_to_set<S: ClosureSink>(&self, set: &mut S) {
+        match *self {
+            FullMappingResult::CodePoint(c) => set.add_char(c),
+            FullMappingResult::String(s) => set.add_string(s),
+            FullMappingResult::Remove => {}
+        }
+    }
+}
+
+impl Writeable for FullMappingResult<'_> {
+    fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {
+        match *self {
+            FullMappingResult::CodePoint(c) => sink.write_char(c),
+            FullMappingResult::String(s) => sink.write_str(s),
+            FullMappingResult::Remove => Ok(()),
+        }
+    }
+}
+
+pub(crate) struct ContextIterator<'a> {
+    before: &'a str,
+    after: &'a str,
+}
+
+impl<'a> ContextIterator<'a> {
+    // Returns a context iterator with the characters before
+    // and after the character at a given index, given the preceding
+    // string and the succeeding string including the character itself
+    pub fn new(before: &'a str, char_and_after: &'a str) -> Self {
+        let mut char_and_after = char_and_after.chars();
+        char_and_after.next(); // skip the character itself
+        let after = char_and_after.as_str();
+        Self { before, after }
+    }
+
+    fn add_greek_diacritics(&self, mut diacritics: GreekDiacritics) -> GreekDiacritics {
+        diacritics.consume_greek_diacritics(self.after);
+        diacritics
+    }
+
+    fn preceded_by_greek_letter(&self) -> bool {
+        greek_to_me::preceded_by_greek_letter(self.before)
+    }
+
+    fn preceding_greek_vowel_diacritics(
+        &self,
+    ) -> Option<GreekCombiningCharacterSequenceDiacritics> {
+        greek_to_me::preceding_greek_vowel_diacritics(self.before)
+    }
+
+    fn preceded_by_soft_dotted(&self, mapping: &CaseMap) -> bool {
+        for c in self.before.chars().rev() {
+            match mapping.dot_type(c) {
+                DotType::SoftDotted => return true,
+                DotType::OtherAccent => continue,
+                _ => return false,
+            }
+        }
+        false
+    }
+    /// Checks if the preceding character is a capital I, allowing for non-Above combining characters in between.
+    ///
+    /// If I_MUST_NOT_START_STRING is true, additionally will require that the capital I does not start the string
+    fn preceded_by_capital_i<const I_MUST_NOT_START_STRING: bool>(
+        &self,
+        mapping: &CaseMap,
+    ) -> bool {
+        let mut iter = self.before.chars().rev();
+        while let Some(c) = iter.next() {
+            if c == 'I' {
+                if I_MUST_NOT_START_STRING {
+                    return iter.next().is_some();
+                } else {
+                    return true;
+                }
+            }
+            if mapping.dot_type(c) != DotType::OtherAccent {
+                break;
+            }
+        }
+        false
+    }
+    fn preceded_by_cased_letter(&self, mapping: &CaseMap) -> bool {
+        for c in self.before.chars().rev() {
+            let data = mapping.lookup_data(c);
+            if !data.is_ignorable() {
+                return data.case_type().is_some();
+            }
+        }
+        false
+    }
+    fn followed_by_cased_letter(&self, mapping: &CaseMap) -> bool {
+        for c in self.after.chars() {
+            let data = mapping.lookup_data(c);
+            if !data.is_ignorable() {
+                return data.case_type().is_some();
+            }
+        }
+        false
+    }
+    fn followed_by_more_above(&self, mapping: &CaseMap) -> bool {
+        for c in self.after.chars() {
+            match mapping.dot_type(c) {
+                DotType::Above => return true,
+                DotType::OtherAccent => continue,
+                _ => return false,
+            }
+        }
+        false
+    }
+    fn followed_by_dot_above(&self, mapping: &CaseMap) -> bool {
+        for c in self.after.chars() {
+            if c == '\u{307}' {
+                return true;
+            }
+            if mapping.dot_type(c) != DotType::OtherAccent {
+                return false;
+            }
+        }
+        false
+    }
+
+    /// Checks the preceding and surrounding context of a j or J
+    /// and returns true if it is preceded by an i or I at the start of the string.
+    /// If one has an acute accent,
+    /// both must have the accent for this to return true. No other accents are handled.
+    fn is_dutch_ij_pair_at_beginning(&self, mapping: &CaseMap) -> bool {
+        let mut before = self.before.chars().rev();
+        let mut i_has_acute = false;
+        loop {
+            match before.next() {
+                Some('i') | Some('I') => break,
+                Some('í') | Some('Í') => {
+                    i_has_acute = true;
+                    break;
+                }
+                Some(ACUTE) => i_has_acute = true,
+                _ => return false,
+            }
+        }
+
+        if before.next().is_some() {
+            // not at the beginning of a string, doesn't matter
+            return false;
+        }
+        let mut j_has_acute = false;
+        for c in self.after.chars() {
+            if c == ACUTE {
+                j_has_acute = true;
+                continue;
+            }
+            // We are supposed to check that `j` has no other combining marks aside
+            // from potentially an acute accent. Once we hit the first non-combining mark
+            // we are done.
+            //
+            // ICU4C checks for `gc=Mn` to determine if something is a combining mark,
+            // however this requires extra data (and is the *only* point in the casemapping algorithm
+            // where there is a direct dependency on properties data not mediated by the casemapping data trie).
+            //
+            // Instead, we can check for ccc via dot_type, the same way the rest of the algorithm does.
+            //
+            // See https://unicode-org.atlassian.net/browse/ICU-22429
+            match mapping.dot_type(c) {
+                // Not a combining character; ccc = 0
+                DotType::NoDot | DotType::SoftDotted => break,
+                // found combining character, bail
+                _ => return false,
+            }
+        }
+
+        // either both should have an acute accent, or none. this is an XNOR operation
+        !(j_has_acute ^ i_has_acute)
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/lib.rs b/third_party/rust/icu_casemap/src/lib.rs
@@ -0,0 +1,70 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! Case mapping for Unicode characters and strings.
+//!
+//! This module is published as its own crate ([`icu_casemap`](https://docs.rs/icu_casemap/latest/icu_casemap/))
+//! and as part of the [`icu`](https://docs.rs/icu/latest/icu/) crate. See the latter for more details on the ICU4X project.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use icu::casemap::CaseMapper;
+//! use icu::locale::langid;
+//!
+//! let cm = CaseMapper::new();
+//!
+//! assert_eq!(
+//!     cm.uppercase_to_string("hello world", &langid!("und")),
+//!     "HELLO WORLD"
+//! );
+//! assert_eq!(
+//!     cm.lowercase_to_string("Γειά σου Κόσμε", &langid!("und")),
+//!     "γειά σου κόσμε"
+//! );
+//! ```
+//!
+//! [`ICU4X`]: ../icu/index.html
+
+// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations
+#![cfg_attr(not(any(test, doc)), no_std)]
+#![cfg_attr(
+    not(test),
+    deny(
+        clippy::indexing_slicing,
+        clippy::unwrap_used,
+        clippy::expect_used,
+        clippy::panic,
+        clippy::exhaustive_structs,
+        clippy::exhaustive_enums,
+        clippy::trivially_copy_pass_by_ref,
+        missing_debug_implementations,
+    )
+)]
+#![warn(missing_docs)]
+// We're using Greek identifiers here on purpose. These lints can only be disabled at the crate level
+#![allow(confusable_idents, uncommon_codepoints)]
+
+extern crate alloc;
+
+mod casemapper;
+mod closer;
+pub mod provider;
+mod set;
+pub(crate) mod titlecase;
+
+#[doc(hidden)] // testing
+#[allow(clippy::exhaustive_structs, clippy::exhaustive_enums)]
+pub mod greek_to_me;
+mod internals;
+
+pub use casemapper::{CaseMapper, CaseMapperBorrowed};
+pub use closer::{CaseMapCloser, CaseMapCloserBorrowed};
+pub use set::ClosureSink;
+pub use titlecase::{TitlecaseMapper, TitlecaseMapperBorrowed};
+
+/// Options used by types in this crate
+pub mod options {
+    pub use crate::titlecase::{LeadingAdjustment, TitlecaseOptions, TrailingCase};
+}
diff --git a/third_party/rust/icu_casemap/src/provider/data.rs b/third_party/rust/icu_casemap/src/provider/data.rs
@@ -0,0 +1,527 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! The primary per-codepoint casefolding data
+
+#[cfg(feature = "datagen")]
+use alloc::collections::BTreeMap;
+use core::num::TryFromIntError;
+use icu_collections::codepointtrie::TrieValue;
+use zerovec::ule::{AsULE, RawBytesULE, UleError, ULE};
+
+/// The case of a Unicode character
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider::data))]
+pub enum CaseType {
+    /// Lowercase letter
+    Lower = 1,
+    /// Uppercase letter
+    Upper = 2,
+    /// Titlecase letter
+    Title = 3,
+}
+
+impl CaseType {
+    pub(crate) const CASE_MASK: u16 = 0x3;
+
+    // The casetype is stored in the codepoint trie as two bits.
+    // After masking them to get a value between 0 and 3, this
+    // function converts to `CaseType`.
+    //
+    // Returns `None` for uncased
+    #[inline]
+    pub(crate) fn from_masked_bits(b: u16) -> Option<Self> {
+        debug_assert!(b & Self::CASE_MASK == b);
+        match b {
+            0 => None,
+            1 => Some(CaseType::Lower),
+            2 => Some(CaseType::Upper),
+            _ => Some(CaseType::Title),
+        }
+    }
+}
+
+/// The dot type of a Unicode character. This indicates how dotted
+/// letters (like `i` and `j`) combine with accents placed above the
+/// letter.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider::data))]
+#[derive(Default)]
+pub enum DotType {
+    /// Normal characters with combining class 0
+    #[default]
+    NoDot = 0,
+    /// Soft-dotted characters with combining class 0
+    SoftDotted = 1,
+    /// "Above" accents with combining class 230
+    Above = 2,
+    /// Other accent characters
+    OtherAccent = 3,
+}
+
+impl DotType {
+    pub(crate) const DOT_MASK: u16 = 0x3;
+
+    // The dot type is stored in either the codepoint trie or the
+    // exception table as two bits.  After shifting and masking them
+    // to get a value between 0 and 3, this function converts to
+    // DotType.
+    #[inline]
+    pub(crate) fn from_masked_bits(b: u16) -> Self {
+        debug_assert!(b & Self::DOT_MASK == b);
+        match b {
+            0 => DotType::NoDot,
+            1 => DotType::SoftDotted,
+            2 => DotType::Above,
+            _ => DotType::OtherAccent,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum MappingKind {
+    Lower = 0,
+    Fold = 1,
+    Upper = 2,
+    Title = 3,
+}
+
+/// Case mapping data associated with a single code point
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider::data))]
+pub struct CaseMapData {
+    /// Whether this is default-ignoreable
+    pub ignoreable: bool,
+    /// The rest of the case mapping data
+    pub kind: CaseMapDataKind,
+}
+
+/// A subset of case mapping data associated with a single code point
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider::data))]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum CaseMapDataKind {
+    /// This code point is an exception. Provides the case type of its own case
+    /// and the exception index stored in [`CaseMapExceptions`]
+    ///
+    /// [`CaseMapExceptions`]: crate::provider::exceptions::CaseMapExceptions
+    Exception(Option<CaseType>, u16),
+    /// This code point is uncased, and has the following extra data
+    Uncased(NonExceptionData),
+    /// This code point is cased. We store the extra data, its case type, and a *delta*
+    /// that can be used to get its casemapped codepoint.
+    Delta(NonExceptionData, CaseType, i16),
+}
+
+/// Data that is stored in CaseMapData when it is *not* an exception
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider::data))]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct NonExceptionData {
+    /// Whether or not the type is case-sensitive
+    pub sensitive: bool,
+    /// The "dot type"
+    pub dot_type: DotType,
+}
+
+impl CaseMapData {
+    #[inline]
+    pub(crate) fn case_type(self) -> Option<CaseType> {
+        match self.kind {
+            CaseMapDataKind::Exception(case_type, ..) => case_type,
+            CaseMapDataKind::Delta(_, case_type, _) => Some(case_type),
+            CaseMapDataKind::Uncased(..) => None,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn is_upper_or_title(self) -> bool {
+        match self.case_type() {
+            None | Some(CaseType::Lower) => false,
+            Some(CaseType::Upper) | Some(CaseType::Title) => true,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn is_relevant_to(self, kind: MappingKind) -> bool {
+        match kind {
+            MappingKind::Lower | MappingKind::Fold => self.is_upper_or_title(),
+            MappingKind::Upper | MappingKind::Title => self.case_type() == Some(CaseType::Lower),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn is_ignorable(self) -> bool {
+        self.ignoreable
+    }
+
+    #[inline]
+    pub(crate) fn has_exception(self) -> bool {
+        matches!(self.kind, CaseMapDataKind::Exception(..))
+    }
+
+    // Returns true if this code point is case-sensitive.
+    // only in the non-exception case
+    // This is not currently exposed.
+    #[inline]
+    pub(crate) fn is_sensitive(self) -> bool {
+        match self.kind {
+            CaseMapDataKind::Exception(..) => false,
+            CaseMapDataKind::Delta(ned, ..) => ned.sensitive,
+            CaseMapDataKind::Uncased(ned) => ned.sensitive,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn dot_type(self) -> DotType {
+        match self.kind {
+            CaseMapDataKind::Exception(..) => DotType::NoDot,
+            CaseMapDataKind::Delta(ned, ..) => ned.dot_type,
+            CaseMapDataKind::Uncased(ned) => ned.dot_type,
+        }
+    }
+
+    // The delta between this code point and its upper/lowercase equivalent.
+    // This should only be called for codepoints without exception data.
+    //
+    // Returns 0 for uncased types
+    #[inline]
+    pub(crate) fn delta(self) -> i16 {
+        debug_assert!(!self.has_exception());
+        match self.kind {
+            CaseMapDataKind::Exception(..) => 0,
+            CaseMapDataKind::Delta(.., delta) => delta,
+            CaseMapDataKind::Uncased(..) => 0,
+        }
+    }
+
+    // The index of the exception data for this codepoint in the exception
+    // table. This should only be called for codepoints with exception data.
+    #[inline]
+    pub(crate) fn exception_index(self) -> u16 {
+        debug_assert!(self.has_exception());
+        if let CaseMapDataKind::Exception(_, i) = self.kind {
+            i
+        } else {
+            0
+        }
+    }
+
+    // CaseMapExceptionsBuilder moves the full mapping and closure
+    // strings out of the exception table itself. This means that the
+    // exception index for a code point in ICU4X will be different
+    // from the exception index for the same codepoint in ICU4C. Given
+    // a mapping from old to new, this function updates the exception
+    // index if necessary.
+    #[cfg(feature = "datagen")]
+    pub(crate) fn with_updated_exception(self, updates: &BTreeMap<u16, u16>) -> Self {
+        let kind = if let CaseMapDataKind::Exception(ty, index) = self.kind {
+            if let Some(updated_exception) = updates.get(&index) {
+                CaseMapDataKind::Exception(ty, *updated_exception)
+            } else {
+                self.kind
+            }
+        } else {
+            self.kind
+        };
+
+        Self { kind, ..self }
+    }
+
+    /// Attempt to construct from ICU-format integer
+    #[cfg(any(feature = "datagen", test))]
+    pub(crate) fn try_from_icu_integer(int: u16) -> Result<Self, UleError> {
+        let raw = int.to_unaligned();
+        CaseMapDataULE::validate_bytes(raw.as_bytes())?;
+
+        let this = Self::from_unaligned(CaseMapDataULE(raw));
+        Ok(this)
+    }
+}
+
+impl TrieValue for CaseMapData {
+    type TryFromU32Error = TryFromIntError;
+
+    fn try_from_u32(i: u32) -> Result<Self, Self::TryFromU32Error> {
+        u16::try_from(i).map(|u| AsULE::from_unaligned(CaseMapDataULE(u.to_unaligned())))
+    }
+
+    fn to_u32(self) -> u32 {
+        u32::from(self.to_unaligned().0.as_unsigned_int())
+    }
+}
+
+/// Packed casemappingdata type
+///
+/// Data format, copied from ICU4C casepropsbuilder.cpp:
+///
+/// ```text
+/// Trie data word:
+/// Bits
+/// if(exception) {
+///     15..4   unsigned exception index
+/// } else {
+///     if(not uncased) {
+///         15..7   signed delta to simple case mapping code point
+///                 (add delta to input code point)
+///     } else {
+///         15..7   reserved, 0
+///     }
+///      6..5   0 normal character with cc=0
+///             1 soft-dotted character
+///             2 cc=230
+///             3 other cc
+///             The runtime code relies on these two bits to be adjacent with this encoding.
+/// }
+///     4   case-sensitive
+///     3   exception
+///     2   case-ignorable
+///  1..0   0 uncased
+///         1 lowercase
+///         2 uppercase
+///         3 titlecase
+///         The runtime code relies on the case-ignorable and case type bits 2..0
+///         to be the lowest bits with this encoding.
+/// ```
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[repr(transparent)]
+pub struct CaseMapDataULE(RawBytesULE<2>);
+
+impl CaseMapDataULE {
+    // 1..0 case type
+    const CASE_TYPE_BITS: u16 = 0x3;
+    // 2 case-ignorable
+    const CASE_IGNOREABLE_BIT: u16 = 0x4;
+    // 3 exception
+    const EXCEPTION_BIT: u16 = 0x8;
+    // 4 case-sensitive
+    const CASE_SENSITIVE_BIT: u16 = 0x10;
+    // 15..4 unsigned exception index
+    const EXCEPTION_SHIFT: u16 = 4;
+    // 15..7 signed-delta to simple case mapping code point (or reserved)
+    const DELTA_SHIFT: u16 = 7;
+    // 6..5 dot type
+    const DOT_TYPE_BITS: u16 = 0x60;
+    const DOT_SHIFT: u16 = 5;
+}
+
+/// # Safety
+///
+/// Safety checklist for `ULE`:
+///
+/// 1. The type *must not* include any uninitialized or padding bytes: repr(transparent)
+///    wrapper around ULE type
+/// 2. The type must have an alignment of 1 byte: repr(transparent) wrapper around ULE type
+/// 3. The impl of [`ULE::validate_bytes()`] *must* return an error if the given byte slice
+///    would not represent a valid slice of this type: It does
+/// 4. The impl of [`ULE::validate_bytes()`] *must* return an error if the given byte slice
+///    cannot be used in its entirety (if its length is not a multiple of `size_of::<Self>()`):
+///    it does, due to the RawBytesULE parse call
+/// 5. All other methods *must* be left with their default impl, or else implemented according to
+///    their respective safety guidelines: They have been
+/// 6. The equality invariant is satisfied
+unsafe impl ULE for CaseMapDataULE {
+    fn validate_bytes(bytes: &[u8]) -> Result<(), UleError> {
+        let sixteens = RawBytesULE::<2>::parse_bytes_to_slice(bytes)?;
+
+        for sixteen in sixteens {
+            let sixteen = sixteen.as_unsigned_int();
+            // The type has reserved bits in the
+            // uncased + not exception case
+            if sixteen & Self::EXCEPTION_BIT == 0 {
+                // not an exception
+                if sixteen & Self::CASE_TYPE_BITS == 0 {
+                    // uncased
+                    if sixteen >> Self::DELTA_SHIFT != 0 {
+                        // We have some used bits in the reserved zone!
+                        return Err(UleError::parse::<Self>());
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl AsULE for CaseMapData {
+    type ULE = CaseMapDataULE;
+
+    fn from_unaligned(ule: Self::ULE) -> Self {
+        let sixteen = ule.0.as_unsigned_int();
+
+        let ignoreable = (sixteen & CaseMapDataULE::CASE_IGNOREABLE_BIT) != 0;
+        let exception = (sixteen & CaseMapDataULE::EXCEPTION_BIT) != 0;
+
+        let case_type = sixteen & CaseMapDataULE::CASE_TYPE_BITS;
+        let case_type = CaseType::from_masked_bits(case_type);
+        let kind = if exception {
+            // No need to mask first since the exception bits start at 15
+            let exception = sixteen >> CaseMapDataULE::EXCEPTION_SHIFT;
+            CaseMapDataKind::Exception(case_type, exception)
+        } else {
+            let dot_type = (sixteen & CaseMapDataULE::DOT_TYPE_BITS) >> CaseMapDataULE::DOT_SHIFT;
+            let dot_type = DotType::from_masked_bits(dot_type);
+            let sensitive = (sixteen & CaseMapDataULE::CASE_SENSITIVE_BIT) != 0;
+            let ned = NonExceptionData {
+                dot_type,
+                sensitive,
+            };
+            if let Some(case_type) = case_type {
+                // no need to mask first since the delta bits start at 15
+                // We can also cast as i16 first so we do not have to
+                // sign-extend later
+                let delta = (sixteen as i16) >> CaseMapDataULE::DELTA_SHIFT;
+                CaseMapDataKind::Delta(ned, case_type, delta)
+            } else {
+                CaseMapDataKind::Uncased(ned)
+            }
+        };
+        CaseMapData { ignoreable, kind }
+    }
+
+    fn to_unaligned(self) -> Self::ULE {
+        let mut sixteen = 0;
+        if self.ignoreable {
+            sixteen |= CaseMapDataULE::CASE_IGNOREABLE_BIT;
+        }
+        match self.kind {
+            CaseMapDataKind::Exception(case_type, e) => {
+                sixteen |= CaseMapDataULE::EXCEPTION_BIT;
+                sixteen |= e << CaseMapDataULE::EXCEPTION_SHIFT;
+                sixteen |= case_type.map(|c| c as u16).unwrap_or(0);
+            }
+            CaseMapDataKind::Uncased(ned) => {
+                sixteen |= (ned.dot_type as u16) << CaseMapDataULE::DOT_SHIFT;
+                if ned.sensitive {
+                    sixteen |= CaseMapDataULE::CASE_SENSITIVE_BIT;
+                }
+                // Remaining bytes are left at zero
+                // case_type is Uncased (0)
+            }
+            CaseMapDataKind::Delta(ned, case_type, delta) => {
+                // First shift (which keeps the signedness), then cast to the
+                // right type
+                sixteen |= (delta << CaseMapDataULE::DELTA_SHIFT) as u16;
+                sixteen |= (ned.dot_type as u16) << CaseMapDataULE::DOT_SHIFT;
+                if ned.sensitive {
+                    sixteen |= CaseMapDataULE::CASE_SENSITIVE_BIT;
+                }
+                sixteen |= case_type as u16;
+            }
+        }
+        CaseMapDataULE(sixteen.to_unaligned())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_roundtrip() {
+        const TESTCASES: &[CaseMapData] = &[
+            CaseMapData {
+                ignoreable: true,
+                kind: CaseMapDataKind::Exception(Some(CaseType::Title), 923),
+            },
+            CaseMapData {
+                ignoreable: false,
+                kind: CaseMapDataKind::Exception(None, 923),
+            },
+            CaseMapData {
+                ignoreable: true,
+                kind: CaseMapDataKind::Delta(
+                    NonExceptionData {
+                        sensitive: true,
+                        dot_type: DotType::SoftDotted,
+                    },
+                    CaseType::Upper,
+                    50,
+                ),
+            },
+            CaseMapData {
+                ignoreable: false,
+                kind: CaseMapDataKind::Delta(
+                    NonExceptionData {
+                        sensitive: true,
+                        dot_type: DotType::SoftDotted,
+                    },
+                    CaseType::Upper,
+                    -50,
+                ),
+            },
+            CaseMapData {
+                ignoreable: false,
+                kind: CaseMapDataKind::Uncased(NonExceptionData {
+                    sensitive: false,
+                    dot_type: DotType::SoftDotted,
+                }),
+            },
+        ];
+
+        for case in TESTCASES {
+            let ule = case.to_unaligned();
+            let roundtrip = CaseMapData::from_unaligned(ule);
+            assert_eq!(*case, roundtrip);
+            let integer = ule.0.as_unsigned_int();
+            let roundtrip2 = CaseMapData::try_from_icu_integer(integer).unwrap();
+            assert_eq!(*case, roundtrip2);
+        }
+    }
+    #[test]
+    fn test_integer_roundtrip() {
+        // Buggy roundtrip cases go here
+        fn test_single_integer(int: u16) {
+            let cmd = CaseMapData::try_from_icu_integer(int).unwrap();
+            assert_eq!(int, cmd.to_unaligned().0.as_unsigned_int())
+        }
+
+        test_single_integer(84);
+        test_single_integer(2503);
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/provider/exception_helpers.rs b/third_party/rust/icu_casemap/src/provider/exception_helpers.rs
@@ -0,0 +1,279 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! This module contains various types for the header part of casemapping exception data
+//!
+//! This is both used in datagen to decode ICU4C's data, and natively in ICU4X's
+//! own data model.
+//!
+//! [`ExceptionBits`] is the bag of bits associated with exceptions, and [`SlotPresence`]
+//! marks the presence or absence of various "slots" in a given exception.
+//!
+//! The `exceptions_builder` module of this crate handles decoding ICU4C data using the exception
+//! header, and [`crate::provider::exceptions`] handles.
+
+use crate::provider::data::{DotType, MappingKind};
+use zerovec::ule::{AsULE, ULE};
+
+/// A bunch of bits associated with each exception.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize))]
+pub struct ExceptionBits {
+    /// Whether or not the slots are double-width.
+    ///
+    /// Unused in ICU4X
+    pub double_width_slots: bool,
+    /// There is no simple casefolding, even if there is a simple lowercase mapping
+    pub no_simple_case_folding: bool,
+    /// The delta stored in the `Delta` slot is negative
+    pub negative_delta: bool,
+    /// If the character is case sensitive
+    pub is_sensitive: bool,
+    /// The dot type of the character
+    pub dot_type: DotType,
+    /// If the character has conditional special casing
+    pub has_conditional_special: bool,
+    /// If the character has conditional case folding
+    pub has_conditional_fold: bool,
+}
+
+impl ExceptionBits {
+    /// Extract from the upper half of an ICU4C-format u16
+    pub(crate) fn from_integer(int: u8) -> Self {
+        let ule = ExceptionBitsULE(int);
+        let double_width_slots = ule.double_width_slots();
+        let no_simple_case_folding = ule.no_simple_case_folding();
+        let negative_delta = ule.negative_delta();
+        let is_sensitive = ule.is_sensitive();
+        let has_conditional_special = ule.has_conditional_special();
+        let has_conditional_fold = ule.has_conditional_fold();
+        let dot_type = ule.dot_type();
+
+        Self {
+            double_width_slots,
+            no_simple_case_folding,
+            negative_delta,
+            is_sensitive,
+            dot_type,
+            has_conditional_special,
+            has_conditional_fold,
+        }
+    }
+
+    /// Convert to an ICU4C-format upper half of u16
+    pub(crate) fn to_integer(self) -> u8 {
+        let mut int = 0;
+        let dot_data = (self.dot_type as u8) << ExceptionBitsULE::DOT_SHIFT;
+        int |= dot_data;
+
+        if self.double_width_slots {
+            int |= ExceptionBitsULE::DOUBLE_SLOTS_FLAG
+        }
+        if self.no_simple_case_folding {
+            int |= ExceptionBitsULE::NO_SIMPLE_CASE_FOLDING_FLAG
+        }
+        if self.negative_delta {
+            int |= ExceptionBitsULE::NEGATIVE_DELTA_FLAG
+        }
+        if self.is_sensitive {
+            int |= ExceptionBitsULE::SENSITIVE_FLAG
+        }
+        if self.has_conditional_special {
+            int |= ExceptionBitsULE::CONDITIONAL_SPECIAL_FLAG
+        }
+        if self.has_conditional_fold {
+            int |= ExceptionBitsULE::CONDITIONAL_FOLD_FLAG
+        }
+        int
+    }
+}
+
+/// Packed slot presence marker
+///
+/// All bits are valid, though bit 4 is unused and reserved
+///
+/// Bits:
+///
+/// ```text
+///               0: Lowercase mapping (code point)
+///               1: Case folding (code point)
+///               2: Uppercase mapping (code point)
+///               3: Titlecase mapping (code point)
+///               4: Delta to simple case mapping (code point) (sign stored separately)
+///               5: RESERVED
+///               6: Closure mappings (string; see below)
+///               7: Full mappings (strings; see below)
+/// ```
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, PartialEq, Eq, ULE, Debug, Default)]
+#[repr(transparent)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize))]
+pub struct SlotPresence(pub u8);
+
+impl SlotPresence {
+    pub(crate) fn add_slot(&mut self, slot: ExceptionSlot) {
+        self.0 |= 1 << slot as u8;
+    }
+    pub(crate) fn has_slot(self, slot: ExceptionSlot) -> bool {
+        let bit = 1 << (slot as u8);
+        self.0 & bit != 0
+    }
+}
+
+/// The bitflags on an exception header.
+///
+/// Format from icu4c, documented in casepropsbuilder.cpp, shifted 8 bits since ICU4C has this packed
+/// alongside a SlotPresence
+///
+/// ```text
+///            0  Double-width slots. If set, then each optional slot is stored as two
+///               elements of the array (high and low halves of 32-bit values) instead of
+///               a single element.
+///            1  Has no simple case folding, even if there is a simple lowercase mapping
+///           2  The value in the delta slot is negative
+///           3  Is case-sensitive (not exposed)
+///       4..5  Dot type
+///           6  Has conditional special casing
+///           7  Has conditional case folding
+/// ```
+///
+/// All bits are valid, though in ICU4X data bits 0 and 2 are not used
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, PartialEq, Eq, ULE, Debug)]
+#[repr(transparent)]
+pub struct ExceptionBitsULE(pub u8);
+
+impl ExceptionBitsULE {
+    const DOUBLE_SLOTS_FLAG: u8 = 0x1;
+
+    const NO_SIMPLE_CASE_FOLDING_FLAG: u8 = 0x2;
+    const NEGATIVE_DELTA_FLAG: u8 = 0x4;
+    const SENSITIVE_FLAG: u8 = 0x8;
+
+    const DOT_SHIFT: u8 = 4;
+
+    const CONDITIONAL_SPECIAL_FLAG: u8 = 0x40;
+    const CONDITIONAL_FOLD_FLAG: u8 = 0x80;
+}
+
+impl ExceptionBitsULE {
+    /// Whether or not the slots are double-width.
+    ///
+    /// Unused in ICU4X
+    pub fn double_width_slots(self) -> bool {
+        self.0 & Self::DOUBLE_SLOTS_FLAG != 0
+    }
+
+    /// There is no simple casefolding, even if there is a simple lowercase mapping
+    pub fn no_simple_case_folding(self) -> bool {
+        self.0 & Self::NO_SIMPLE_CASE_FOLDING_FLAG != 0
+    }
+
+    /// The delta stored in the `Delta` slot is negative
+    pub fn negative_delta(self) -> bool {
+        self.0 & Self::NEGATIVE_DELTA_FLAG != 0
+    }
+
+    /// If the character is case sensitive
+    pub fn is_sensitive(self) -> bool {
+        self.0 & Self::SENSITIVE_FLAG != 0
+    }
+
+    /// If the character has conditional special casing
+    pub fn has_conditional_special(self) -> bool {
+        self.0 & Self::CONDITIONAL_SPECIAL_FLAG != 0
+    }
+
+    /// If the character has conditional case folding
+    pub fn has_conditional_fold(self) -> bool {
+        self.0 & Self::CONDITIONAL_FOLD_FLAG != 0
+    }
+
+    /// The dot type of the character
+    pub fn dot_type(self) -> DotType {
+        DotType::from_masked_bits((u16::from(self.0 >> Self::DOT_SHIFT)) & DotType::DOT_MASK)
+    }
+}
+
+impl AsULE for ExceptionBits {
+    type ULE = ExceptionBitsULE;
+    fn from_unaligned(u: ExceptionBitsULE) -> Self {
+        ExceptionBits::from_integer(u.0)
+    }
+
+    fn to_unaligned(self) -> ExceptionBitsULE {
+        ExceptionBitsULE(self.to_integer())
+    }
+}
+
+impl AsULE for SlotPresence {
+    type ULE = SlotPresence;
+    fn from_unaligned(u: Self) -> Self {
+        u
+    }
+
+    fn to_unaligned(self) -> Self {
+        self
+    }
+}
+
+/// The different slots that may be present in slot-based exception data
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub(crate) enum ExceptionSlot {
+    /// Lowercase mapping
+    Lower = 0,
+    /// Case folding
+    Fold = 1,
+    /// Uppercase mapping
+    Upper = 2,
+    /// Titlecase mapping
+    Title = 3,
+    /// The delta to the simple case folding
+    Delta = 4,
+    // Slot 5 is reserved
+    /// The closure set
+    Closure = 6,
+    /// The four full-mappings
+    FullMappings = 7,
+}
+
+impl ExceptionSlot {
+    /// Where the string slots begin
+    pub(crate) const STRING_SLOTS_START: Self = Self::Closure;
+}
+
+impl From<MappingKind> for ExceptionSlot {
+    fn from(full: MappingKind) -> Self {
+        match full {
+            MappingKind::Lower => Self::Lower,
+            MappingKind::Fold => Self::Fold,
+            MappingKind::Upper => Self::Upper,
+            MappingKind::Title => Self::Title,
+        }
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/provider/exceptions.rs b/third_party/rust/icu_casemap/src/provider/exceptions.rs
@@ -0,0 +1,566 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! This is the main module pertaining to casemapping exceptions.
+//!
+//! A single exception is represented by the [`Exception`] type and its ULE equivalent.
+//!
+//! The storage format is complicated (and documented on [`Exception`]), but the data format is
+//! represented equally by [`DecodedException`], which is more human-readable.
+use icu_provider::prelude::*;
+
+use super::data::MappingKind;
+use super::exception_helpers::{ExceptionBits, ExceptionSlot, SlotPresence};
+use crate::set::ClosureSink;
+use alloc::borrow::Cow;
+use core::fmt;
+#[cfg(any(feature = "serde", feature = "datagen"))]
+use core::ops::Range;
+use core::ptr;
+use zerovec::ule::AsULE;
+use zerovec::VarZeroVec;
+
+const SURROGATES_START: u32 = 0xD800;
+const SURROGATES_LEN: u32 = 0xDFFF - SURROGATES_START + 1;
+
+/// This represents case mapping exceptions that can't be represented as a delta applied to
+/// the original code point. The codepoint
+/// trie in CaseMapper stores indices into this VarZeroVec.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider::exceptions))]
+#[derive(Debug, Eq, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
+pub struct CaseMapExceptions<'data> {
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    /// The list of exceptions
+    pub exceptions: VarZeroVec<'data, ExceptionULE>,
+}
+
+impl CaseMapExceptions<'_> {
+    /// Obtain the exception at index `idx`. Will
+    /// return a default value if not present (GIGO behavior),
+    /// as these indices should come from a paired CaseMapData object
+    ///
+    /// Will also panic in debug mode
+    pub fn get(&self, idx: u16) -> &ExceptionULE {
+        let exception = self.exceptions.get(idx.into());
+        debug_assert!(exception.is_some());
+
+        exception.unwrap_or(ExceptionULE::empty_exception())
+    }
+
+    #[cfg(any(feature = "serde", feature = "datagen"))]
+    pub(crate) fn validate(&self) -> Result<Range<u16>, &'static str> {
+        for exception in self.exceptions.iter() {
+            exception.validate()?;
+        }
+        u16::try_from(self.exceptions.len())
+            .map_err(|_| "Too many exceptions")
+            .map(|l| 0..l)
+    }
+}
+/// A type representing the wire format of `Exception`. The data contained is
+/// equivalently represented by [`DecodedException`].
+///
+/// This type is itself not used that much, most of its relevant methods live
+/// on [`ExceptionULE`].
+///
+/// The `bits` contain supplementary data, whereas
+/// `slot_presence` marks te presence of various extra data
+/// in the `data` field.
+///
+/// The `data` field is not validated to contain all of this data,
+/// this type will have GIGO behavior when constructed with invalid `data`.
+///
+/// The format of `data` is documented on the field
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[zerovec::make_varule(ExceptionULE)]
+#[derive(PartialEq, Eq, Clone, Default, Debug)]
+#[zerovec::skip_derive(Ord)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Deserialize),
+    zerovec::derive(Deserialize)
+)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(serde::Serialize),
+    zerovec::derive(Serialize)
+)]
+pub struct Exception<'a> {
+    /// The various bit based exception data associated with this.
+    ///
+    /// Format: Just a u8 of bitflags, some flags unused. See [`ExceptionBits`] and its ULE type for more.
+    pub bits: ExceptionBits,
+    /// Which slots are present in `data`.
+    ///
+    /// Format: a u8 of bitflags
+    pub slot_presence: SlotPresence,
+    /// Format : `[char slots] [optional closure length] [ closure slot ] [ full mappings data ]`
+    ///
+    /// For each set SlotPresence bit, except for the two stringy slots (Closure/FullMapping),
+    /// this will have one entry in the string, packed together.
+    ///
+    /// Note that the simple_case delta is stored as a u32 normalized to a `char`, where u32s
+    /// which are from or beyond the surrogate range 0xD800-0xDFFF are stored as chars
+    /// starting from 0xE000. The sign is stored in bits.negative_delta.
+    ///
+    /// If both Closure/FullMapping are present, the next char will be the length of the closure slot,
+    /// bisecting the rest of the data.
+    /// If only one is present, the rest of the data represents that slot.
+    ///
+    /// The closure slot simply represents one string. The full-mappings slot represents four strings,
+    /// packed in a way similar to VarZeroVec, in the following format:
+    /// `i1 i2 i3 [ str0 ] [ str1 ] [ str2 ] [ str3 ]`
+    ///
+    /// where `i1 i2 i3` are the indices of the relevant mappings string. The strings are stored in
+    /// the order corresponding to the MappingKind enum.
+    pub data: Cow<'a, str>,
+}
+
+impl ExceptionULE {
+    #[inline]
+    fn empty_exception() -> &'static Self {
+        static EMPTY_BYTES: &[u8] = &[0, 0];
+        // Safety:
+        // ExceptionULE is a packed DST with `(u8, u8, unsized)` fields. All bit patterns are valid for the two u8s
+        //
+        // An "empty" one can be constructed from a slice of two u8s
+        unsafe {
+            let slice: *const [u8] = ptr::slice_from_raw_parts(EMPTY_BYTES.as_ptr(), 0);
+            &*(slice as *const Self)
+        }
+    }
+    pub(crate) fn has_slot(&self, slot: ExceptionSlot) -> bool {
+        self.slot_presence.has_slot(slot)
+    }
+    /// Obtain a `char` slot, if occupied. If `slot` represents a string slot,
+    /// will return `None`
+    pub(crate) fn get_char_slot(&self, slot: ExceptionSlot) -> Option<char> {
+        if slot >= ExceptionSlot::STRING_SLOTS_START {
+            return None;
+        }
+        let bit = 1 << (slot as u8);
+        // check if slot is occupied
+        if self.slot_presence.0 & bit == 0 {
+            return None;
+        }
+
+        let previous_slot_mask = bit - 1;
+        let previous_slots = self.slot_presence.0 & previous_slot_mask;
+        let slot_num = previous_slots.count_ones() as usize;
+        self.data.chars().nth(slot_num)
+    }
+
+    /// Get the `simple_case` delta (i.e. the `delta` slot), given the character
+    /// this data belongs to.
+    ///
+    /// Normalizes the delta from char-format to u32 format
+    ///
+    /// Does *not* handle the sign of the delta; see self.bits.negative_delta
+    fn get_simple_case_delta(&self) -> Option<u32> {
+        let delta_ch = self.get_char_slot(ExceptionSlot::Delta)?;
+        let mut delta = u32::from(delta_ch);
+        // We "fill in" the surrogates range by offsetting deltas greater than it
+        if delta >= SURROGATES_START {
+            delta -= SURROGATES_LEN;
+        }
+        Some(delta)
+    }
+
+    /// Get the `simple_case` value (i.e. the `delta` slot), given the character
+    /// this data belongs to.
+    ///
+    /// The data is stored as a delta so the character must be provided.
+    ///
+    /// The data cannot be stored directly as a character because the trie is more
+    /// compact with adjacent characters sharing deltas.
+    pub(crate) fn get_simple_case_slot_for(&self, ch: char) -> Option<char> {
+        let delta = self.get_simple_case_delta()?;
+        let mut delta = i32::try_from(delta).ok()?;
+        if self.bits.negative_delta() {
+            delta = -delta;
+        }
+
+        let new_ch = i32::try_from(u32::from(ch)).ok()? + delta;
+
+        char::try_from(u32::try_from(new_ch).ok()?).ok()
+    }
+
+    /// Returns *all* the data in the closure/full slots, including length metadata
+    fn get_stringy_data(&self) -> Option<&str> {
+        const CHAR_MASK: u8 = (1 << ExceptionSlot::STRING_SLOTS_START as u8) - 1;
+        let char_slot_count = (self.slot_presence.0 & CHAR_MASK).count_ones() as usize;
+        let mut chars = self.data.chars();
+        for _ in 0..char_slot_count {
+            let res = chars.next();
+            res?;
+        }
+        Some(chars.as_str())
+    }
+
+    /// Returns a single stringy slot, either ExceptionSlot::Closure
+    /// or ExceptionSlot::FullMappings.
+    fn get_stringy_slot(&self, slot: ExceptionSlot) -> Option<&str> {
+        debug_assert!(slot == ExceptionSlot::Closure || slot == ExceptionSlot::FullMappings);
+        let other_slot = if slot == ExceptionSlot::Closure {
+            ExceptionSlot::FullMappings
+        } else {
+            ExceptionSlot::Closure
+        };
+        if !self.slot_presence.has_slot(slot) {
+            return None;
+        }
+        let stringy_data = self.get_stringy_data()?;
+
+        if self.slot_presence.has_slot(other_slot) {
+            // both stringy slots are used, we need a length
+            let mut chars = stringy_data.chars();
+            // GIGO: to have two strings there must be a length, if not present return None
+            let length_char = chars.next()?;
+
+            let length = usize::try_from(u32::from(length_char)).unwrap_or(0);
+            // The length indexes into the string after the first char
+            let remaining_slice = chars.as_str();
+            // GIGO: will return none if there wasn't enough space in this slot
+            if slot == ExceptionSlot::Closure {
+                remaining_slice.get(0..length)
+            } else {
+                remaining_slice.get(length..)
+            }
+        } else {
+            // only a single stringy slot, there is no length stored
+            Some(stringy_data)
+        }
+    }
+
+    /// Get the data behind the `closure` slot
+    pub(crate) fn get_closure_slot(&self) -> Option<&str> {
+        self.get_stringy_slot(ExceptionSlot::Closure)
+    }
+
+    /// Get all the slot data for the FullMappings slot
+    ///
+    /// This needs to be further segmented into four based on length metadata
+    fn get_fullmappings_slot_data(&self) -> Option<&str> {
+        self.get_stringy_slot(ExceptionSlot::FullMappings)
+    }
+
+    /// Get a specific FullMappings slot value
+    pub(crate) fn get_fullmappings_slot_for_kind(&self, kind: MappingKind) -> Option<&str> {
+        let data = self.get_fullmappings_slot_data()?;
+
+        let mut chars = data.chars();
+        // GIGO: must have three index strings, else return None
+        let i1 = usize::try_from(u32::from(chars.next()?)).ok()?;
+        let i2 = usize::try_from(u32::from(chars.next()?)).ok()?;
+        let i3 = usize::try_from(u32::from(chars.next()?)).ok()?;
+        let remaining_slice = chars.as_str();
+        // GIGO: if the indices are wrong, return None
+        match kind {
+            MappingKind::Lower => remaining_slice.get(..i1),
+            MappingKind::Fold => remaining_slice.get(i1..i2),
+            MappingKind::Upper => remaining_slice.get(i2..i3),
+            MappingKind::Title => remaining_slice.get(i3..),
+        }
+    }
+
+    // convenience function that lets us use the ? operator
+    fn get_all_fullmapping_slots(&self) -> Option<[Cow<'_, str>; 4]> {
+        Some([
+            self.get_fullmappings_slot_for_kind(MappingKind::Lower)?
+                .into(),
+            self.get_fullmappings_slot_for_kind(MappingKind::Fold)?
+                .into(),
+            self.get_fullmappings_slot_for_kind(MappingKind::Upper)?
+                .into(),
+            self.get_fullmappings_slot_for_kind(MappingKind::Title)?
+                .into(),
+        ])
+    }
+
+    // Given a mapping kind, returns the character for that kind, if it exists. Fold falls
+    // back to Lower; Title falls back to Upper.
+    #[inline]
+    pub(crate) fn slot_char_for_kind(&self, kind: MappingKind) -> Option<char> {
+        match kind {
+            MappingKind::Lower | MappingKind::Upper => self.get_char_slot(kind.into()),
+            MappingKind::Fold => self
+                .get_char_slot(ExceptionSlot::Fold)
+                .or_else(|| self.get_char_slot(ExceptionSlot::Lower)),
+            MappingKind::Title => self
+                .get_char_slot(ExceptionSlot::Title)
+                .or_else(|| self.get_char_slot(ExceptionSlot::Upper)),
+        }
+    }
+
+    pub(crate) fn add_full_and_closure_mappings<S: ClosureSink>(&self, set: &mut S) {
+        if let Some(full) = self.get_fullmappings_slot_for_kind(MappingKind::Fold) {
+            if !full.is_empty() {
+                set.add_string(full);
+            }
+        };
+        if let Some(closure) = self.get_closure_slot() {
+            for c in closure.chars() {
+                set.add_char(c);
+            }
+        };
+    }
+
+    /// Extract all the data out into a structured form
+    ///
+    /// Useful for serialization and debugging
+    pub fn decode(&self) -> DecodedException<'_> {
+        // Potential future optimization: This can
+        // directly access each bit one after the other and iterate the string
+        // which avoids recomputing slot offsets over and over again.
+        //
+        // If we're doing so we may wish to retain this older impl so that we can still roundtrip test
+        let bits = self.bits;
+        let lowercase = self.get_char_slot(ExceptionSlot::Lower);
+        let casefold = self.get_char_slot(ExceptionSlot::Fold);
+        let uppercase = self.get_char_slot(ExceptionSlot::Upper);
+        let titlecase = self.get_char_slot(ExceptionSlot::Title);
+        let simple_case_delta = self.get_simple_case_delta();
+        let closure = self.get_closure_slot().map(Into::into);
+        let full = self.get_all_fullmapping_slots();
+
+        DecodedException {
+            bits: ExceptionBits::from_unaligned(bits),
+            lowercase,
+            casefold,
+            uppercase,
+            titlecase,
+            simple_case_delta,
+            closure,
+            full,
+        }
+    }
+
+    #[cfg(any(feature = "serde", feature = "datagen"))]
+    pub(crate) fn validate(&self) -> Result<(), &'static str> {
+        // check that ICU4C specific fields are not set
+        // check that there is enough space for all the offsets
+        if self.bits.double_width_slots() {
+            return Err("double-width-slots should not be used in ICU4C");
+        }
+
+        // just run all of the slot getters at once and then check
+        let decoded = self.decode();
+
+        for (slot, decoded_slot) in [
+            (ExceptionSlot::Lower, &decoded.lowercase),
+            (ExceptionSlot::Fold, &decoded.casefold),
+            (ExceptionSlot::Upper, &decoded.uppercase),
+            (ExceptionSlot::Title, &decoded.titlecase),
+        ] {
+            if self.has_slot(slot) && decoded_slot.is_none() {
+                // decoding hit GIGO behavior, oops!
+                return Err("Slot decoding failed");
+            }
+        }
+        if self.has_slot(ExceptionSlot::Delta) && decoded.simple_case_delta.is_none() {
+            // decoding hit GIGO behavior, oops!
+            return Err("Slot decoding failed");
+        }
+
+        if self.has_slot(ExceptionSlot::Closure) && decoded.closure.is_none() {
+            return Err("Slot decoding failed");
+        }
+
+        if self.has_slot(ExceptionSlot::FullMappings) {
+            if decoded.full.is_some() {
+                let data = self
+                    .get_fullmappings_slot_data()
+                    .ok_or("fullmappings slot doesn't parse")?;
+                let mut chars = data.chars();
+                let i1 = u32::from(chars.next().ok_or("fullmappings string too small")?);
+                let i2 = u32::from(chars.next().ok_or("fullmappings string too small")?);
+                let i3 = u32::from(chars.next().ok_or("fullmappings string too small")?);
+
+                if i2 < i1 || i3 < i2 {
+                    return Err("fullmappings string contains non-sequential indices");
+                }
+                let rest = chars.as_str();
+                let len = u32::try_from(rest.len()).map_err(|_| "len too large for u32")?;
+
+                if i1 > len || i2 > len || i3 > len {
+                    return Err("fullmappings string contains out-of-bounds indices");
+                }
+            } else {
+                return Err("Slot decoding failed");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Debug for ExceptionULE {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.decode().fmt(f)
+    }
+}
+
+/// A decoded [`Exception`] type, with all of the data parsed out into
+/// separate fields.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize))]
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct DecodedException<'a> {
+    /// The various bit-based data associated with this exception
+    pub bits: ExceptionBits,
+    /// Lowercase mapping
+    pub lowercase: Option<char>,
+    /// Case folding
+    pub casefold: Option<char>,
+    /// Uppercase mapping
+    pub uppercase: Option<char>,
+    /// Titlecase mapping
+    pub titlecase: Option<char>,
+    /// The simple casefold delta. Its sign is stored in bits.negative_delta
+    pub simple_case_delta: Option<u32>,
+    /// Closure mappings
+    pub closure: Option<Cow<'a, str>>,
+    /// The four full-mappings strings, indexed by MappingKind u8 value
+    pub full: Option<[Cow<'a, str>; 4]>,
+}
+
+impl DecodedException<'_> {
+    /// Convert to a wire-format encodeable (VarULE-encodeable) [`Exception`]
+    pub fn encode(&self) -> Exception<'static> {
+        let bits = self.bits;
+        let mut slot_presence = SlotPresence(0);
+        let mut data = alloc::string::String::new();
+        if let Some(lowercase) = self.lowercase {
+            slot_presence.add_slot(ExceptionSlot::Lower);
+            data.push(lowercase)
+        }
+        if let Some(casefold) = self.casefold {
+            slot_presence.add_slot(ExceptionSlot::Fold);
+            data.push(casefold)
+        }
+        if let Some(uppercase) = self.uppercase {
+            slot_presence.add_slot(ExceptionSlot::Upper);
+            data.push(uppercase)
+        }
+        if let Some(titlecase) = self.titlecase {
+            slot_presence.add_slot(ExceptionSlot::Title);
+            data.push(titlecase)
+        }
+        if let Some(mut simple_case_delta) = self.simple_case_delta {
+            slot_presence.add_slot(ExceptionSlot::Delta);
+
+            if simple_case_delta >= SURROGATES_START {
+                simple_case_delta += SURROGATES_LEN;
+            }
+            let simple_case_delta = char::try_from(simple_case_delta).unwrap_or('\0');
+            data.push(simple_case_delta)
+        }
+
+        if let Some(ref closure) = self.closure {
+            slot_presence.add_slot(ExceptionSlot::Closure);
+            if self.full.is_some() {
+                // GIGO: if the closure length is more than 0xD800 this will error. Plenty of space.
+                debug_assert!(
+                    closure.len() < 0xD800,
+                    "Found overlarge closure value when encoding exception"
+                );
+                let len_char = u32::try_from(closure.len())
+                    .ok()
+                    .and_then(|c| char::try_from(c).ok())
+                    .unwrap_or('\0');
+                data.push(len_char);
+            }
+            data.push_str(closure);
+        }
+        if let Some(ref full) = self.full {
+            slot_presence.add_slot(ExceptionSlot::FullMappings);
+            let mut idx = 0;
+            // iterate all elements except the last, whose length we can calculate from context
+            for mapping in full.iter().take(3) {
+                idx += mapping.len();
+                data.push(char::try_from(u32::try_from(idx).unwrap_or(0)).unwrap_or('\0'));
+            }
+            for mapping in full {
+                data.push_str(mapping);
+            }
+        }
+        Exception {
+            bits,
+            slot_presence,
+            data: data.into(),
+        }
+    }
+
+    // Potential optimization: Write an `EncodeAsVarULE` that
+    // directly produces an ExceptionULE
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_roundtrip_once(exception: DecodedException) {
+        let encoded = exception.encode();
+        let encoded = zerovec::ule::encode_varule_to_box(&encoded);
+        let decoded = encoded.decode();
+        assert_eq!(decoded, exception);
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        test_roundtrip_once(DecodedException {
+            lowercase: Some('ø'),
+            ..Default::default()
+        });
+        test_roundtrip_once(DecodedException {
+            titlecase: Some('X'),
+            lowercase: Some('ø'),
+            ..Default::default()
+        });
+        test_roundtrip_once(DecodedException {
+            titlecase: Some('X'),
+            ..Default::default()
+        });
+        test_roundtrip_once(DecodedException {
+            titlecase: Some('X'),
+            simple_case_delta: Some(0xE999),
+            closure: Some("hello world".into()),
+            ..Default::default()
+        });
+        test_roundtrip_once(DecodedException {
+            simple_case_delta: Some(10),
+            closure: Some("hello world".into()),
+            full: Some(["你好世界".into(), "".into(), "hi".into(), "å".into()]),
+            ..Default::default()
+        });
+        test_roundtrip_once(DecodedException {
+            closure: Some("hello world".into()),
+            full: Some(["aa".into(), "ț".into(), "".into(), "å".into()]),
+            ..Default::default()
+        });
+        test_roundtrip_once(DecodedException {
+            full: Some(["你好世界".into(), "".into(), "hi".into(), "å".into()]),
+            ..Default::default()
+        });
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/provider/exceptions_builder.rs b/third_party/rust/icu_casemap/src/provider/exceptions_builder.rs
@@ -0,0 +1,290 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::provider::exception_helpers::{
+    ExceptionBits, ExceptionBitsULE, ExceptionSlot, SlotPresence,
+};
+use crate::provider::exceptions::{CaseMapExceptions, DecodedException};
+use alloc::borrow::Cow;
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use alloc::vec::Vec;
+use icu_provider::DataError;
+use zerovec::ule::{AsULE, ULE};
+
+/// The header for exception types as found in ICU4C data. See [`ExceptionHeaderULE`]
+/// for the wire format
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct ExceptionHeader {
+    /// The various slots that are present, masked by ExceptionSlot
+    ///
+    /// We still store this as a bitmask since it's more convenient to access as one
+    pub slot_presence: SlotPresence,
+    pub bits: ExceptionBits,
+}
+
+impl ExceptionHeader {
+    /// Construct from an ICU4C-format u16.
+    pub(crate) fn from_integer(int: u16) -> Self {
+        let slot_presence =
+            SlotPresence(u8::try_from(int & ExceptionHeaderULE::SLOTS_MASK).unwrap_or(0));
+        let bits = ExceptionBits::from_integer(
+            u8::try_from(int >> ExceptionHeaderULE::BITS_SHIFT).unwrap_or(0),
+        );
+        Self {
+            slot_presence,
+            bits,
+        }
+    }
+
+    // Returns true if the given slot exists for this exception
+    pub(crate) fn has_slot(self, slot: ExceptionSlot) -> bool {
+        self.slot_presence.has_slot(slot)
+    }
+}
+
+/// Packed exception header (format from icu4c, documented in casepropsbuilder.cpp)
+///
+/// ```text
+///       Bits:
+///         0..7  Flag bits indicating which optional slots are present (if any):
+///               0: Lowercase mapping (code point)
+///               1: Case folding (code point)
+///               2: Uppercase mapping (code point)
+///               3: Titlecase mapping (code point)
+///               4: Delta to simple case mapping (code point) (sign stored separately)
+///               5: RESERVED
+///               6: Closure mappings (string; see below)
+///               7: Full mappings (strings; see below)
+///            8  Double-width slots. If set, then each optional slot is stored as two
+///               elements of the array (high and low halves of 32-bit values) instead of
+///               a single element.
+///            9  Has no simple case folding, even if there is a simple lowercase mapping
+///           10  The value in the delta slot is negative
+///           11  Is case-sensitive (not exposed)
+///       12..13  Dot type
+///           14  Has conditional special casing
+///           15  Has conditional case folding
+/// ```
+///
+/// In this struct the RESERVED bit is still allowed to be set, and it will produce a different
+/// exception header, but it will not have any other effects.
+#[derive(Copy, Clone, PartialEq, Eq, ULE)]
+#[repr(C, packed)]
+pub struct ExceptionHeaderULE {
+    slot_presence: SlotPresence,
+    bits: ExceptionBitsULE,
+}
+
+impl ExceptionHeaderULE {
+    const SLOTS_MASK: u16 = 0xff;
+    const BITS_SHIFT: u16 = 8;
+}
+
+impl AsULE for ExceptionHeader {
+    type ULE = ExceptionHeaderULE;
+    fn from_unaligned(u: ExceptionHeaderULE) -> Self {
+        Self {
+            slot_presence: u.slot_presence,
+            bits: ExceptionBits::from_integer(u.bits.0),
+        }
+    }
+
+    fn to_unaligned(self) -> ExceptionHeaderULE {
+        ExceptionHeaderULE {
+            slot_presence: self.slot_presence,
+            bits: ExceptionBitsULE(self.bits.to_integer()),
+        }
+    }
+}
+// CaseMapExceptionsBuilder consumes the exceptions data produced by
+// casepropsbuilder.cpp in ICU4C. It generates an instance of CaseMapExceptions. The
+// primary difference is that the ICU4C representation stores full mapping and closure
+// strings inline in the data, while CaseMapExceptions uses a side table. As a result,
+// the starting index of each exception in the resulting CaseMapExceptions may have
+// changed, so we also produce a map from old indices to new indices that will be used to
+// update the data stored in the code point trie.
+pub struct CaseMapExceptionsBuilder<'a> {
+    raw_data: &'a [u16],
+    raw_data_idx: usize,
+    double_slots: bool,
+}
+
+impl<'a> CaseMapExceptionsBuilder<'a> {
+    const MAPPINGS_ALL_LENGTHS_MASK: u32 = 0xffff;
+    const FULL_MAPPINGS_LENGTH_MASK: u32 = 0xf;
+    const FULL_MAPPINGS_LENGTH_SHIFT: u32 = 4;
+
+    const CLOSURE_MAX_LENGTH: u32 = 0xf;
+
+    pub fn new(raw_data: &'a [u16]) -> Self {
+        Self {
+            raw_data,
+            raw_data_idx: 0,
+            double_slots: false,
+        }
+    }
+
+    fn done(&self) -> bool {
+        self.raw_data_idx >= self.raw_data.len()
+    }
+    fn read_raw(&mut self) -> Result<u16, DataError> {
+        let result = self
+            .raw_data
+            .get(self.raw_data_idx)
+            .ok_or(DataError::custom("Incomplete exception data"))?;
+        self.raw_data_idx += 1;
+        Ok(*result)
+    }
+
+    fn read_slot(&mut self) -> Result<u32, DataError> {
+        if self.double_slots {
+            let hi = self.read_raw()? as u32;
+            let lo = self.read_raw()? as u32;
+            Ok((hi << 16) | lo)
+        } else {
+            Ok(self.read_raw()? as u32)
+        }
+    }
+
+    // After reading a string out of the raw data, advance raw_data_idx.
+    fn skip_string(&mut self, s: &str) {
+        for c in s.chars() {
+            self.raw_data_idx += c.len_utf16();
+        }
+    }
+
+    pub(crate) fn build(
+        mut self,
+    ) -> Result<(CaseMapExceptions<'static>, BTreeMap<u16, u16>), DataError> {
+        let mut exceptions = Vec::new();
+        let mut idx_map = BTreeMap::new();
+        // The format of the raw data from ICU4C is the same as the format described in
+        // exceptions.rs, with the exception of full mapping and closure strings. The
+        // header and non-string slots can be copied over without modification. For string
+        // slots, we read the length information from the ICU4C slot (described below),
+        // read the strings, add the strings to the CaseMapExceptions string table,
+        // and write an updated slot value containing the index of the string in the
+        // table. In the case of full mappings, we store the index of the lowercase
+        // mapping; the remaining mappings are stored at sequential indices.
+        //
+        // Full mappings: If there is at least one full (string) case mapping, then the
+        // lengths of the mappings are encoded as nibbles in the full mappings slot:
+        //     Bits:
+        //        0..4   Length of lowercase string
+        //        5..7   Length of case folding string
+        //        8..11  Length of uppercase string
+        //        12..15 Length of titlecase string
+        // Mappings that do not exist have length 0. The strings themselves are stored in
+        // the above order immediately following the last optional slot, encoded as UTF16.
+        //
+        // Case closure: If the case closure for a code point includes code points that
+        // are not included in the simple or full mappings, then bits 0..3 of the closure
+        // mappings slot will contain the number of codepoints in the closure string.
+        // (Other bits are reserved.) The closure string itself is encoded as UTF16 and
+        // stored following the full mappings data (if it exists) or the final optional
+        // slot.
+        while !self.done() {
+            let old_idx = self.raw_data_idx as u16;
+
+            let mut exception = DecodedException::default();
+
+            // Copy header.
+            let header = ExceptionHeader::from_integer(self.read_raw()?);
+            self.double_slots = header.bits.double_width_slots;
+
+            // Copy unmodified slots.
+            for (slot, output) in [
+                (ExceptionSlot::Lower, &mut exception.lowercase),
+                (ExceptionSlot::Fold, &mut exception.casefold),
+                (ExceptionSlot::Upper, &mut exception.uppercase),
+                (ExceptionSlot::Title, &mut exception.titlecase),
+            ] {
+                if header.has_slot(slot) {
+                    let value = self.read_slot()?;
+                    if let Ok(ch) = char::try_from(value) {
+                        *output = Some(ch)
+                    } else {
+                        return Err(DataError::custom(
+                            "Found non-char value in casemapping exceptions data",
+                        ));
+                    }
+                }
+            }
+            if header.has_slot(ExceptionSlot::Delta) {
+                let delta = self.read_slot()?;
+
+                exception.simple_case_delta = Some(delta)
+            }
+
+            // Read the closure and full mappings slots, if they exist.
+            let closure_length = if header.has_slot(ExceptionSlot::Closure) {
+                Some((self.read_slot()? & Self::CLOSURE_MAX_LENGTH) as usize)
+            } else {
+                None
+            };
+            let mappings_lengths = if header.has_slot(ExceptionSlot::FullMappings) {
+                Some(self.read_slot()? & Self::MAPPINGS_ALL_LENGTHS_MASK)
+            } else {
+                None
+            };
+
+            // Copy the full mappings strings into the strings table, if they exist.
+            if let Some(mut lengths) = mappings_lengths {
+                let mut arr: [Cow<_>; 4] = Default::default();
+                for mapping in &mut arr {
+                    let len = lengths & Self::FULL_MAPPINGS_LENGTH_MASK;
+                    lengths >>= Self::FULL_MAPPINGS_LENGTH_SHIFT;
+
+                    let start = self.raw_data_idx;
+                    let end = start + len as usize;
+                    let slice = &self
+                        .raw_data
+                        .get(start..end)
+                        .ok_or(DataError::custom("Incomplete string data"))?;
+                    let string = char::decode_utf16(slice.iter().copied())
+                        .collect::<Result<String, _>>()
+                        .map_err(|_| DataError::custom("Found non-utf16 exceptions data"))?;
+                    self.skip_string(&string);
+                    *mapping = string.into()
+                }
+                exception.full = Some(arr)
+            }
+
+            // Copy the closure string into the strings table, if it exists.
+            if let Some(len) = closure_length {
+                let start = self.raw_data_idx;
+                let slice = &self
+                    .raw_data
+                    .get(start..)
+                    .ok_or(DataError::custom("Incomplete string data"))?;
+                let string = char::decode_utf16(slice.iter().copied())
+                    .take(len)
+                    .collect::<Result<String, _>>()
+                    .map_err(|_| DataError::custom("Found non-utf16 exceptions data"))?;
+                self.skip_string(&string);
+                exception.closure = Some(string.into())
+            }
+
+            exception.bits = header.bits;
+            // unused bits in ICU4X
+            exception.bits.double_width_slots = false;
+
+            let new_exception_index = if let Ok(idx) = u16::try_from(exceptions.len()) {
+                idx
+            } else {
+                return Err(DataError::custom("More than u16 exceptions"));
+            };
+            idx_map.insert(old_idx, new_exception_index);
+            exceptions.push(exception.encode());
+        }
+
+        Ok((
+            CaseMapExceptions {
+                exceptions: (&exceptions).into(),
+            },
+            idx_map,
+        ))
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/provider/mod.rs b/third_party/rust/icu_casemap/src/provider/mod.rs
@@ -0,0 +1,202 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! 🚧 \[Unstable\] Data provider struct definitions for this ICU4X component.
+//!
+//! <div class="stab unstable">
+//! 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+//! including in SemVer minor releases. While the serde representation of data structs is guaranteed
+//! to be stable, their Rust representation might not be. Use with caution.
+//! </div>
+//!
+//! Read more about data providers: [`icu_provider`]
+
+// Provider structs must be stable
+#![allow(clippy::exhaustive_structs, clippy::exhaustive_enums)]
+
+use icu_provider::prelude::*;
+
+use crate::provider::data::CaseMapData;
+use crate::provider::exceptions::CaseMapExceptions;
+use icu_collections::codepointtrie::CodePointTrie;
+#[cfg(feature = "datagen")]
+use icu_collections::codepointtrie::CodePointTrieHeader;
+
+pub mod data;
+pub mod exception_helpers;
+pub mod exceptions;
+#[cfg(feature = "datagen")]
+mod exceptions_builder;
+mod unfold;
+
+#[cfg(feature = "compiled_data")]
+#[derive(Debug)]
+/// Baked data
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. In particular, the `DataProvider` implementations are only
+/// guaranteed to match with this version's `*_unstable` providers. Use with caution.
+/// </div>
+pub struct Baked;
+
+#[cfg(feature = "compiled_data")]
+#[allow(unused_imports)]
+const _: () = {
+    use icu_casemap_data::*;
+    pub mod icu {
+        pub use crate as casemap;
+        pub use icu_collections as collections;
+    }
+    make_provider!(Baked);
+    impl_case_map_v1!(Baked);
+    impl_case_map_unfold_v1!(Baked);
+};
+
+icu_provider::data_marker!(
+    /// Marker for casemapping data.
+    CaseMapV1,
+    "case/map/v1",
+    CaseMap<'static>,
+    is_singleton = true
+);
+
+icu_provider::data_marker!(
+    /// Reverse case mapping data.
+    CaseMapUnfoldV1,
+    "case/map/unfold/v1",
+    CaseMapUnfold<'static>,
+    is_singleton = true
+);
+
+#[cfg(feature = "datagen")]
+/// The latest minimum set of markers required by this component.
+pub const MARKERS: &[DataMarkerInfo] = &[CaseMapUnfoldV1::INFO, CaseMapV1::INFO];
+
+pub use self::unfold::CaseMapUnfold;
+
+/// This type contains all of the casemapping data
+///
+/// The methods in the provider module are primarily about accessing its data,
+/// however the full algorithms are also implemented as methods on this type in
+/// the `internals` module of this crate.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider))]
+#[yoke(prove_covariance_manually)]
+/// CaseMapper provides low-level access to the data necessary to
+/// convert characters and strings to upper, lower, or title case.
+pub struct CaseMap<'data> {
+    /// Case mapping data
+    pub trie: CodePointTrie<'data, CaseMapData>,
+    /// Exceptions to the case mapping data
+    pub exceptions: CaseMapExceptions<'data>,
+}
+
+icu_provider::data_struct!(
+    CaseMap<'_>,
+    #[cfg(feature = "datagen")]
+);
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CaseMap<'de> {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        #[derive(serde::Deserialize)]
+        pub struct Raw<'data> {
+            #[serde(borrow)]
+            pub trie: CodePointTrie<'data, CaseMapData>,
+            #[serde(borrow)]
+            pub exceptions: CaseMapExceptions<'data>,
+        }
+
+        let Raw { trie, exceptions } = Raw::deserialize(deserializer)?;
+        let result = Self { trie, exceptions };
+        debug_assert!(result.validate().is_ok());
+        Ok(result)
+    }
+}
+
+impl CaseMap<'_> {
+    /// Creates a new CaseMap using data exported by the
+    // `icuexportdata` tool in ICU4C. Validates that the data is
+    // consistent.
+    #[cfg(feature = "datagen")]
+    pub fn try_from_icu(
+        trie_header: CodePointTrieHeader,
+        trie_index: &[u16],
+        trie_data: &[u16],
+        exceptions: &[u16],
+    ) -> Result<Self, DataError> {
+        use self::exceptions_builder::CaseMapExceptionsBuilder;
+        use zerovec::ZeroVec;
+        let exceptions_builder = CaseMapExceptionsBuilder::new(exceptions);
+        let (exceptions, idx_map) = exceptions_builder.build()?;
+
+        let trie_index = ZeroVec::alloc_from_slice(trie_index);
+
+        #[allow(clippy::unwrap_used)] // datagen only
+        let trie_data = trie_data
+            .iter()
+            .map(|&i| {
+                CaseMapData::try_from_icu_integer(i)
+                    .unwrap()
+                    .with_updated_exception(&idx_map)
+            })
+            .collect::<ZeroVec<_>>();
+
+        let trie = CodePointTrie::try_new(trie_header, trie_index, trie_data)
+            .map_err(|_| DataError::custom("Casemapping data does not form valid trie"))?;
+
+        let result = Self { trie, exceptions };
+        result.validate().map_err(DataError::custom)?;
+        Ok(result)
+    }
+
+    /// Given an existing CaseMapper, validates that the data is
+    /// consistent. A CaseMapper created by the ICU transformer has
+    /// already been validated. Calling this function is only
+    /// necessary if you are concerned about data corruption after
+    /// deserializing.
+    #[cfg(any(feature = "serde", feature = "datagen"))]
+    #[allow(unused)] // is only used in debug mode for serde
+    pub(crate) fn validate(&self) -> Result<(), &'static str> {
+        // First, validate that exception data is well-formed.
+        let valid_exception_indices = self.exceptions.validate()?;
+
+        let validate_delta = |c: char, delta: i32| -> Result<(), &'static str> {
+            let new_c =
+                u32::try_from(c as i32 + delta).map_err(|_| "Delta larger than character")?;
+            char::from_u32(new_c).ok_or("Invalid delta")?;
+            Ok(())
+        };
+
+        for i in 0..char::MAX as u32 {
+            if let Some(c) = char::from_u32(i) {
+                let data = self.lookup_data(c);
+                if data.has_exception() {
+                    let idx = data.exception_index();
+                    let exception = self.exceptions.get(idx);
+                    // Verify that the exception index points to a valid exception header.
+                    if !valid_exception_indices.contains(&idx) {
+                        return Err("Invalid exception index in trie data");
+                    }
+                    exception.validate()?;
+                } else {
+                    validate_delta(c, data.delta() as i32)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn lookup_data(&self, c: char) -> CaseMapData {
+        self.trie.get32(c as u32)
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/provider/unfold.rs b/third_party/rust/icu_casemap/src/provider/unfold.rs
@@ -0,0 +1,105 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! Data for reverse folding
+
+#[cfg(feature = "datagen")]
+use alloc::string::String;
+use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
+use zerovec::ZeroMap;
+
+/// Reverse case folding data. Maps from multi-character strings back
+/// to code-points that fold to those strings.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", databake(path = icu_casemap::provider))]
+#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
+#[yoke(prove_covariance_manually)]
+pub struct CaseMapUnfold<'data> {
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    /// The actual map. Maps from strings to a list of codepoints, stored as a contiguous UTF-8 string
+    pub map: ZeroMap<'data, PotentialUtf8, str>,
+}
+
+icu_provider::data_struct!(
+    CaseMapUnfold<'_>,
+    #[cfg(feature = "datagen")]
+);
+
+impl CaseMapUnfold<'_> {
+    /// Creates a new CaseMapUnfold using data exported by the `icuexportdata` tool in ICU4C.
+    ///
+    /// Unfold data is exported by ICU as an array of 16-bit values, representing a short
+    /// header followed by a two-column key/value table. The header indicates:
+    /// - The number of rows.
+    /// - The number of UTF16 code units per row.
+    /// - The number of UTF16 code units in the first (key) column.
+    ///   (The number of code units in the value column can be derived from the above.)
+    ///
+    /// The key in the first column is the case folding of each of the code points in
+    /// the second column. Keys/values that are shorter than the column width are
+    /// null-terminated. The table is sorted by key. Binary search is used to find the value.
+    ///
+    /// Rust strings are UTF8 by default. To avoid the cost of converting from UTF16 on access,
+    /// we convert the ICU data into a more convenient format during construction.
+    #[cfg(feature = "datagen")]
+    #[allow(clippy::indexing_slicing)] // panics are ok in datagen
+    pub fn try_from_icu(raw: &[u16]) -> Result<Self, DataError> {
+        const ROWS_INDEX: usize = 0;
+        const ROW_WIDTH_INDEX: usize = 1;
+        const STRING_WIDTH_INDEX: usize = 2;
+
+        if raw.len() <= STRING_WIDTH_INDEX {
+            return Err(DataError::custom("Unfold: header missing"));
+        }
+
+        let num_rows = raw[ROWS_INDEX] as usize;
+        let row_width = raw[ROW_WIDTH_INDEX] as usize;
+        let string_width = raw[STRING_WIDTH_INDEX] as usize;
+
+        if row_width == 0 {
+            return Err(DataError::custom("Unfold: invalid row width"));
+        }
+
+        // Header takes up one row.
+        let row_data = &raw[row_width..];
+
+        let mut map = ZeroMap::new();
+
+        debug_assert!(num_rows == row_data.chunks_exact(row_width).count());
+        for row in row_data.chunks_exact(row_width) {
+            let key = Self::decode_string(&row[..string_width])
+                .ok_or(DataError::custom("Unfold: unpaired surrogate in key"))?;
+            let val = Self::decode_string(&row[string_width..])
+                .ok_or(DataError::custom("Unfold: unpaired surrogate in value"))?;
+            if map
+                .try_append(PotentialUtf8::from_str(&key), val.as_ref())
+                .is_some()
+            {
+                return Err(DataError::custom("Unfold: keys not sorted/unique"));
+            }
+        }
+        Ok(Self { map })
+    }
+
+    // Decode a zero-terminated UTF16 string from a slice of u16.
+    #[cfg(feature = "datagen")]
+    pub(crate) fn decode_string(slice: &[u16]) -> Option<String> {
+        let iter = slice.iter().copied().take_while(|&c| c != 0);
+        char::decode_utf16(iter).collect::<Result<String, _>>().ok()
+    }
+
+    // Given a string, returns another string representing the set of characters
+    // that case fold to that string.
+    pub(crate) fn get(&self, key: &str) -> Option<&str> {
+        self.map.get(PotentialUtf8::from_str(key))
+    }
+}
diff --git a/third_party/rust/icu_casemap/src/set.rs b/third_party/rust/icu_casemap/src/set.rs
@@ -0,0 +1,36 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use icu_collections::codepointinvlist::CodePointInversionListBuilder;
+
+/// An object that accepts characters and/or strings
+/// to be used with [`CaseMapCloserBorrowed::add_string_case_closure_to()`]
+/// and [`CaseMapCloserBorrowed::add_case_closure_to()`].
+///
+/// Usually this object
+/// will be some kind of set over codepoints and strings, or something that
+/// can be built into one.
+///
+/// An implementation is provided for [`CodePointInversionListBuilder`], but users are encouraged
+/// to implement this trait on their own collections as needed.
+///
+/// [`CaseMapCloserBorrowed::add_string_case_closure_to()`]: crate::CaseMapCloserBorrowed::add_string_case_closure_to
+/// [`CaseMapCloserBorrowed::add_case_closure_to()`]: crate::CaseMapCloserBorrowed::add_case_closure_to
+pub trait ClosureSink {
+    /// Add a character to the set
+    fn add_char(&mut self, c: char);
+    /// Add a string to the set
+    fn add_string(&mut self, string: &str);
+}
+
+impl ClosureSink for CodePointInversionListBuilder {
+    fn add_char(&mut self, c: char) {
+        self.add_char(c)
+    }
+
+    // The current version of CodePointInversionList doesn't include strings.
+    // Trying to add a string is a no-op that will be optimized away.
+    #[inline]
+    fn add_string(&mut self, _string: &str) {}
+}
diff --git a/third_party/rust/icu_casemap/src/titlecase.rs b/third_party/rust/icu_casemap/src/titlecase.rs
@@ -0,0 +1,486 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! Titlecasing-specific
+use crate::provider::CaseMapV1;
+use crate::{CaseMapper, CaseMapperBorrowed};
+use alloc::borrow::Cow;
+use icu_locale_core::LanguageIdentifier;
+use icu_properties::props::{GeneralCategory, GeneralCategoryGroup};
+use icu_properties::provider::PropertyEnumGeneralCategoryV1;
+use icu_properties::{CodePointMapData, CodePointMapDataBorrowed};
+use icu_provider::prelude::*;
+use writeable::Writeable;
+
+/// How to handle the rest of the string once the beginning of the
+/// string has been titlecased.
+///
+/// # Examples
+///
+/// ```rust
+/// use icu::casemap::options::{TitlecaseOptions, TrailingCase};
+/// use icu::casemap::TitlecaseMapper;
+/// use icu::locale::langid;
+///
+/// let cm = TitlecaseMapper::new();
+/// let root = langid!("und");
+///
+/// let default_options = Default::default();
+/// let mut preserve_case: TitlecaseOptions = Default::default();
+/// preserve_case.trailing_case = Some(TrailingCase::Unchanged);
+///
+/// // Exhibits trailing case when set:
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("spOngeBoB", &root, default_options),
+///     "Spongebob"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("spOngeBoB", &root, preserve_case),
+///     "SpOngeBoB"
+/// );
+/// ```
+#[non_exhaustive]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash, Debug)]
+pub enum TrailingCase {
+    /// Preserve the casing of the rest of the string ("spoNgEBoB" -> "SpoNgEBoB")
+    Unchanged,
+    /// Lowercase the rest of the string ("spoNgEBoB" -> "Spongebob")
+    #[default]
+    Lower,
+}
+
+/// Where to start casing the string.
+///
+/// [`TitlecaseMapper`] by default performs "leading adjustment", where it searches for the first "relevant" character
+/// in the string before initializing the actual titlecasing. For example, it will skip punctuation at the beginning
+/// of a string, allowing for strings like `'twas` or `«hello»` to be appropriately titlecased.
+///
+/// Opinions on exactly what is a "relevant" character may differ. In "adjust to cased" mode the first cased character is considered "relevant",
+/// whereas in the "auto" mode, it is the first character that is a letter, number, symbol, or private use character. This means
+/// that the strings `49ers` and `«丰(abc)»` will titlecase in "adjust to cased" mode to `49Ers` and `«丰(Abc)»`, whereas in the "auto" mode they stay unchanged.
+/// This difference largely matters for things that mix numbers and letters, or mix writing systems, within a single segment.
+///
+/// # Examples
+///
+/// ```rust
+/// use icu::casemap::options::{LeadingAdjustment, TitlecaseOptions};
+/// use icu::casemap::TitlecaseMapper;
+/// use icu::locale::langid;
+///
+/// let cm = TitlecaseMapper::new();
+/// let root = langid!("und");
+///
+/// let default_options = Default::default(); // head adjustment set to Auto
+/// let mut no_adjust: TitlecaseOptions = Default::default();
+/// let mut adjust_to_cased: TitlecaseOptions = Default::default();
+/// no_adjust.leading_adjustment = Some(LeadingAdjustment::None);
+/// adjust_to_cased.leading_adjustment = Some(LeadingAdjustment::ToCased);
+///
+/// // Exhibits leading adjustment when set:
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("«hello»", &root, default_options),
+///     "«Hello»"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("«hello»", &root, adjust_to_cased),
+///     "«Hello»"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("«hello»", &root, no_adjust),
+///     "«hello»"
+/// );
+///
+/// // Only changed in adjust-to-cased mode:
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("丰(abc)", &root, default_options),
+///     "丰(abc)"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("丰(abc)", &root, adjust_to_cased),
+///     "丰(Abc)"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("丰(abc)", &root, no_adjust),
+///     "丰(abc)"
+/// );
+///
+/// // Only changed in adjust-to-cased mode:
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("49ers", &root, default_options),
+///     "49ers"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("49ers", &root, adjust_to_cased),
+///     "49Ers"
+/// );
+/// assert_eq!(
+///     cm.titlecase_segment_to_string("49ers", &root, no_adjust),
+///     "49ers"
+/// );
+/// ```
+#[non_exhaustive]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash, Debug)]
+pub enum LeadingAdjustment {
+    /// Start titlecasing immediately, even if the character is not one that is relevant for casing
+    /// ("'twixt" -> "'twixt", "twixt" -> "Twixt")
+    None,
+    /// Adjust the string to the first relevant character before beginning to apply casing
+    /// ("'twixt" -> "'Twixt"). "Relevant" character is picked by best available algorithm,
+    /// by default will adjust to first letter, number, symbol, or private use character,
+    /// but if no data is available (e.g. this API is being called via [`CaseMapperBorrowed::titlecase_segment_with_only_case_data()`]),
+    /// then may be equivalent to "adjust to cased".
+    ///
+    /// This is the default
+    #[default]
+    Auto,
+    /// Adjust the string to the first cased character before beginning to apply casing
+    /// ("'twixt" -> "'Twixt")
+    ToCased,
+}
+
+/// Various options for controlling titlecasing
+///
+/// See docs of [`TitlecaseMapper`] for examples.
+#[non_exhaustive]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash, Debug)]
+pub struct TitlecaseOptions {
+    /// How to handle the rest of the string once the head of the
+    /// string has been titlecased
+    ///
+    /// Default is [`TrailingCase::Lower`]
+    pub trailing_case: Option<TrailingCase>,
+    /// Whether to start casing at the beginning of the string or at the first
+    /// relevant character.
+    ///
+    /// Default is [`LeadingAdjustment::Auto`]
+    pub leading_adjustment: Option<LeadingAdjustment>,
+}
+
+/// A wrapper around [`CaseMapper`] that can compute titlecasing stuff, and is able to load additional data
+/// to support the non-legacy "head adjustment" behavior.
+///
+///
+/// Most methods for this type live on [`TitlecaseMapperBorrowed`], which you can obtain via
+/// [`TitlecaseMapper::new()`] or [`TitlecaseMapper::as_borrowed()`].
+///
+/// By default, [`TitlecaseMapperBorrowed::titlecase_segment()`] and [`TitlecaseMapperBorrowed::titlecase_segment_to_string()`] perform "leading adjustment",
+/// where they wait till the first relevant character to begin titlecasing. For example, in the string `'twixt`, the apostrophe
+/// is ignored because the word starts at the first "t", which will get titlecased (producing `'Twixt`). Other punctuation will
+/// also be ignored, like in the string `«hello»`, which will get titlecased to `«Hello»`.
+///
+/// This is a separate type from [`CaseMapper`] because it loads the additional data
+/// required by [`LeadingAdjustment::Auto`] to perform the best possible leading adjustment.
+///
+/// If you are planning on only using [`LeadingAdjustment::None`] or [`LeadingAdjustment::ToCased`], consider using [`CaseMapper`] directly; this
+/// type will have no additional behavior.
+///
+/// # Examples
+///
+/// Basic casemapping behavior:
+///
+/// ```rust
+/// use icu::casemap::TitlecaseMapper;
+/// use icu::locale::langid;
+///
+/// let cm = TitlecaseMapper::new();
+/// let root = langid!("und");
+///
+/// let default_options = Default::default();
+///
+/// // note that the subsequent words are not titlecased, this function assumes
+/// // that the entire string is a single segment and only titlecases at the beginning.
+/// assert_eq!(cm.titlecase_segment_to_string("hEllO WorLd", &root, default_options), "Hello world");
+/// assert_eq!(cm.titlecase_segment_to_string("Γειά σου Κόσμε", &root, default_options), "Γειά σου κόσμε");
+/// assert_eq!(cm.titlecase_segment_to_string("नमस्ते दुनिया", &root, default_options), "नमस्ते दुनिया");
+/// assert_eq!(cm.titlecase_segment_to_string("Привет мир", &root, default_options), "Привет мир");
+///
+/// // Some behavior is language-sensitive
+/// assert_eq!(cm.titlecase_segment_to_string("istanbul", &root, default_options), "Istanbul");
+/// assert_eq!(cm.titlecase_segment_to_string("istanbul", &langid!("tr"), default_options), "İstanbul"); // Turkish dotted i
+///
+/// assert_eq!(cm.titlecase_segment_to_string("և Երևանի", &root, default_options), "Եւ երևանի");
+/// assert_eq!(cm.titlecase_segment_to_string("և Երևանի", &langid!("hy"), default_options), "Եվ երևանի"); // Eastern Armenian ech-yiwn ligature
+///
+/// assert_eq!(cm.titlecase_segment_to_string("ijkdijk", &root, default_options), "Ijkdijk");
+/// assert_eq!(cm.titlecase_segment_to_string("ijkdijk", &langid!("nl"), default_options), "IJkdijk"); // Dutch IJ digraph
+/// ```
+#[derive(Clone, Debug)]
+pub struct TitlecaseMapper<CM> {
+    cm: CM,
+    gc: CodePointMapData<GeneralCategory>,
+}
+
+impl TitlecaseMapper<CaseMapper> {
+    icu_provider::gen_buffer_data_constructors!(() -> error: DataError,
+    functions: [
+        new: skip,
+        try_new_with_buffer_provider,
+        try_new_unstable,
+        Self,
+    ]);
+
+    #[doc = icu_provider::gen_buffer_unstable_docs!(UNSTABLE, Self::new)]
+    pub fn try_new_unstable<P>(provider: &P) -> Result<Self, DataError>
+    where
+        P: DataProvider<CaseMapV1> + DataProvider<PropertyEnumGeneralCategoryV1> + ?Sized,
+    {
+        let cm = CaseMapper::try_new_unstable(provider)?;
+        let gc = icu_properties::CodePointMapData::<icu_properties::props::GeneralCategory>::try_new_unstable(provider)?;
+        Ok(Self { cm, gc })
+    }
+}
+
+impl TitlecaseMapper<CaseMapper> {
+    /// A constructor which creates a [`TitlecaseMapperBorrowed`] using compiled data
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    #[allow(clippy::new_ret_no_self)] // Intentional
+    pub const fn new() -> TitlecaseMapperBorrowed<'static> {
+        TitlecaseMapperBorrowed::new()
+    }
+}
+// We use Borrow, not AsRef, since we want the blanket impl on T
+impl<CM: AsRef<CaseMapper>> TitlecaseMapper<CM> {
+    icu_provider::gen_buffer_data_constructors!((casemapper: CM) -> error: DataError,
+    functions: [
+        new_with_mapper: skip,
+        try_new_with_mapper_with_buffer_provider,
+        try_new_with_mapper_unstable,
+        Self,
+    ]);
+
+    /// A constructor which creates a [`TitlecaseMapper`] from an existing [`CaseMapper`]
+    /// (either owned or as a reference) and compiled data
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    pub const fn new_with_mapper(casemapper: CM) -> Self {
+        Self {
+            cm: casemapper,
+            gc: icu_properties::CodePointMapData::<icu_properties::props::GeneralCategory>::new()
+                .static_to_owned(),
+        }
+    }
+
+    /// Construct this object to wrap an existing CaseMapper (or a reference to one), loading additional data as needed.
+    #[doc = icu_provider::gen_buffer_unstable_docs!(UNSTABLE, Self::new_with_mapper)]
+    pub fn try_new_with_mapper_unstable<P>(provider: &P, casemapper: CM) -> Result<Self, DataError>
+    where
+        P: DataProvider<CaseMapV1> + DataProvider<PropertyEnumGeneralCategoryV1> + ?Sized,
+    {
+        let gc = icu_properties::CodePointMapData::<icu_properties::props::GeneralCategory>::try_new_unstable(provider)?;
+        Ok(Self { cm: casemapper, gc })
+    }
+
+    /// Constructs a borrowed version of this type for more efficient querying.
+    pub fn as_borrowed(&self) -> TitlecaseMapperBorrowed<'_> {
+        TitlecaseMapperBorrowed {
+            cm: self.cm.as_ref().as_borrowed(),
+            gc: self.gc.as_borrowed(),
+        }
+    }
+}
+
+/// A borrowed [`TitlecaseMapper`].
+///
+/// See methods or [`TitlecaseMapper`] for examples.
+#[derive(Clone, Debug, Copy)]
+pub struct TitlecaseMapperBorrowed<'a> {
+    cm: CaseMapperBorrowed<'a>,
+    gc: CodePointMapDataBorrowed<'a, GeneralCategory>,
+}
+
+impl TitlecaseMapperBorrowed<'static> {
+    /// A constructor which creates a [`TitlecaseMapperBorrowed`] using compiled data
+    ///
+    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
+    ///
+    /// [📚 Help choosing a constructor](icu_provider::constructors)
+    #[cfg(feature = "compiled_data")]
+    pub const fn new() -> Self {
+        Self {
+            cm: CaseMapper::new(),
+            gc: icu_properties::CodePointMapData::<icu_properties::props::GeneralCategory>::new(),
+        }
+    }
+    /// Cheaply converts a [`TitlecaseMapperBorrowed<'static>`] into a [`TitlecaseMapper`].
+    ///
+    /// Note: Due to branching and indirection, using [`TitlecaseMapper`] might inhibit some
+    /// compile-time optimizations that are possible with [`TitlecaseMapper`].
+    pub const fn static_to_owned(self) -> TitlecaseMapper<CaseMapper> {
+        TitlecaseMapper {
+            cm: self.cm.static_to_owned(),
+            gc: self.gc.static_to_owned(),
+        }
+    }
+}
+
+#[cfg(feature = "compiled_data")]
+impl Default for TitlecaseMapperBorrowed<'static> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> TitlecaseMapperBorrowed<'a> {
+    /// Returns the full titlecase mapping of the given string as a [`Writeable`], treating
+    /// the string as a single segment (and thus only titlecasing the beginning of it).
+    ///
+    /// This should typically be used as a lower-level helper to construct the titlecasing operation desired
+    /// by the application, for example one can titlecase on a per-word basis by mixing this with
+    /// a `WordSegmenter`.
+    ///
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// See [`TitlecaseMapperBorrowed::titlecase_segment_to_string()`] for the equivalent convenience function that returns a String,
+    /// as well as for an example.
+    pub fn titlecase_segment(
+        self,
+        src: &'a str,
+        langid: &LanguageIdentifier,
+        options: TitlecaseOptions,
+    ) -> impl Writeable + 'a {
+        if options.leading_adjustment.unwrap_or_default() == LeadingAdjustment::Auto {
+            // letter, number, symbol, or private use code point
+            const HEAD_GROUPS: GeneralCategoryGroup = GeneralCategoryGroup::Letter
+                .union(GeneralCategoryGroup::Number)
+                .union(GeneralCategoryGroup::Symbol)
+                .union(GeneralCategoryGroup::PrivateUse);
+            self.cm
+                .titlecase_segment_with_adjustment(src, langid, options, |_data, ch| {
+                    HEAD_GROUPS.contains(self.gc.get(ch))
+                })
+        } else {
+            self.cm
+                .titlecase_segment_with_adjustment(src, langid, options, |data, ch| {
+                    data.is_cased(ch)
+                })
+        }
+    }
+
+    /// Returns the full titlecase mapping of the given string as a String, treating
+    /// the string as a single segment (and thus only titlecasing the beginning of it).
+    ///
+    /// This should typically be used as a lower-level helper to construct the titlecasing operation desired
+    /// by the application, for example one can titlecase on a per-word basis by mixing this with
+    /// a `WordSegmenter`.
+    ///
+    /// This function is context and language sensitive. Callers should pass the text's language
+    /// as a `LanguageIdentifier` (usually the `id` field of the `Locale`) if available, or
+    /// `Default::default()` for the root locale.
+    ///
+    /// See [`TitlecaseMapperBorrowed::titlecase_segment()`] for the equivalent lower-level function that returns a [`Writeable`]
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use icu::casemap::TitlecaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = TitlecaseMapper::new();
+    /// let root = langid!("und");
+    ///
+    /// let default_options = Default::default();
+    ///
+    /// // note that the subsequent words are not titlecased, this function assumes
+    /// // that the entire string is a single segment and only titlecases at the beginning.
+    /// assert_eq!(cm.titlecase_segment_to_string("hEllO WorLd", &root, default_options), "Hello world");
+    /// assert_eq!(cm.titlecase_segment_to_string("Γειά σου Κόσμε", &root, default_options), "Γειά σου κόσμε");
+    /// assert_eq!(cm.titlecase_segment_to_string("नमस्ते दुनिया", &root, default_options), "नमस्ते दुनिया");
+    /// assert_eq!(cm.titlecase_segment_to_string("Привет мир", &root, default_options), "Привет мир");
+    ///
+    /// // Some behavior is language-sensitive
+    /// assert_eq!(cm.titlecase_segment_to_string("istanbul", &root, default_options), "Istanbul");
+    /// assert_eq!(cm.titlecase_segment_to_string("istanbul", &langid!("tr"), default_options), "İstanbul"); // Turkish dotted i
+    ///
+    /// assert_eq!(cm.titlecase_segment_to_string("և Երևանի", &root, default_options), "Եւ երևանի");
+    /// assert_eq!(cm.titlecase_segment_to_string("և Երևանի", &langid!("hy"), default_options), "Եվ երևանի"); // Eastern Armenian ech-yiwn ligature
+    ///
+    /// assert_eq!(cm.titlecase_segment_to_string("ijkdijk", &root, default_options), "Ijkdijk");
+    /// assert_eq!(cm.titlecase_segment_to_string("ijkdijk", &langid!("nl"), default_options), "IJkdijk"); // Dutch IJ digraph
+    /// ```
+    ///
+    /// Leading adjustment behaviors:
+    ///
+    /// ```rust
+    /// use icu::casemap::options::{LeadingAdjustment, TitlecaseOptions};
+    /// use icu::casemap::TitlecaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = TitlecaseMapper::new();
+    /// let root = langid!("und");
+    ///
+    /// let default_options = Default::default();
+    /// let mut no_adjust: TitlecaseOptions = Default::default();
+    /// no_adjust.leading_adjustment = Some(LeadingAdjustment::None);
+    ///
+    /// // Exhibits leading adjustment when set:
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("«hello»", &root, default_options),
+    ///     "«Hello»"
+    /// );
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("«hello»", &root, no_adjust),
+    ///     "«hello»"
+    /// );
+    ///
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("'Twas", &root, default_options),
+    ///     "'Twas"
+    /// );
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("'Twas", &root, no_adjust),
+    ///     "'twas"
+    /// );
+    ///
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("", &root, default_options),
+    ///     ""
+    /// );
+    /// assert_eq!(cm.titlecase_segment_to_string("", &root, no_adjust), "");
+    /// ```
+    ///
+    /// Tail casing behaviors:
+    ///
+    /// ```rust
+    /// use icu::casemap::options::{TitlecaseOptions, TrailingCase};
+    /// use icu::casemap::TitlecaseMapper;
+    /// use icu::locale::langid;
+    ///
+    /// let cm = TitlecaseMapper::new();
+    /// let root = langid!("und");
+    ///
+    /// let default_options = Default::default();
+    /// let mut preserve_case: TitlecaseOptions = Default::default();
+    /// preserve_case.trailing_case = Some(TrailingCase::Unchanged);
+    ///
+    /// // Exhibits trailing case when set:
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("spOngeBoB", &root, default_options),
+    ///     "Spongebob"
+    /// );
+    /// assert_eq!(
+    ///     cm.titlecase_segment_to_string("spOngeBoB", &root, preserve_case),
+    ///     "SpOngeBoB"
+    /// );
+    /// ```
+    pub fn titlecase_segment_to_string<'s>(
+        self,
+        src: &'s str,
+        langid: &LanguageIdentifier,
+        options: TitlecaseOptions,
+    ) -> Cow<'s, str> {
+        writeable::to_string_or_borrow(
+            &self.titlecase_segment(src, langid, options),
+            src.as_bytes(),
+        )
+    }
+}
diff --git a/third_party/rust/icu_casemap/tests/conversions.rs b/third_party/rust/icu_casemap/tests/conversions.rs
@@ -0,0 +1,409 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use icu_casemap::CaseMapper;
+use icu_locale_core::langid;
+
+#[test]
+fn test_simple_mappings() {
+    let case_mapping = CaseMapper::new();
+
+    // Basic case mapping
+    assert_eq!(case_mapping.simple_uppercase('a'), 'A');
+    assert_eq!(case_mapping.simple_lowercase('a'), 'a');
+    assert_eq!(case_mapping.simple_titlecase('a'), 'A');
+    assert_eq!(case_mapping.simple_fold('a'), 'a');
+    assert_eq!(case_mapping.simple_uppercase('A'), 'A');
+    assert_eq!(case_mapping.simple_lowercase('A'), 'a');
+    assert_eq!(case_mapping.simple_titlecase('A'), 'A');
+    assert_eq!(case_mapping.simple_fold('A'), 'a');
+
+    // Case mapping of titlecase character
+    assert_eq!(case_mapping.simple_uppercase('\u{1c4}'), '\u{1c4}');
+    assert_eq!(case_mapping.simple_titlecase('\u{1c4}'), '\u{1c5}');
+    assert_eq!(case_mapping.simple_lowercase('\u{1c4}'), '\u{1c6}');
+    assert_eq!(case_mapping.simple_uppercase('\u{1c5}'), '\u{1c4}');
+    assert_eq!(case_mapping.simple_titlecase('\u{1c5}'), '\u{1c5}');
+    assert_eq!(case_mapping.simple_lowercase('\u{1c5}'), '\u{1c6}');
+    assert_eq!(case_mapping.simple_uppercase('\u{1c6}'), '\u{1c4}');
+    assert_eq!(case_mapping.simple_titlecase('\u{1c6}'), '\u{1c5}');
+    assert_eq!(case_mapping.simple_lowercase('\u{1c6}'), '\u{1c6}');
+
+    // Turkic case folding
+    assert_eq!(case_mapping.simple_fold('I'), 'i');
+    assert_eq!(case_mapping.simple_fold_turkic('I'), 'ı');
+    assert_eq!(case_mapping.simple_fold('İ'), 'İ');
+    assert_eq!(case_mapping.simple_fold_turkic('İ'), 'i');
+
+    // Supplementary code points (Deseret)
+    assert_eq!(case_mapping.simple_uppercase('\u{1043c}'), '\u{10414}');
+    assert_eq!(case_mapping.simple_lowercase('\u{1043c}'), '\u{1043c}');
+    assert_eq!(case_mapping.simple_titlecase('\u{1043c}'), '\u{10414}');
+    assert_eq!(case_mapping.simple_fold('\u{1043c}'), '\u{1043c}');
+    assert_eq!(case_mapping.simple_uppercase('\u{10414}'), '\u{10414}');
+    assert_eq!(case_mapping.simple_lowercase('\u{10414}'), '\u{1043c}');
+    assert_eq!(case_mapping.simple_titlecase('\u{10414}'), '\u{10414}');
+    assert_eq!(case_mapping.simple_fold('\u{10414}'), '\u{1043c}');
+}
+
+// These and the below tests are taken from StringCaseTest::TestCaseConversion in ICU4C.
+#[test]
+fn test_full_mappings() {
+    let case_mapping = CaseMapper::new();
+    let root = langid!("und");
+    let tr = langid!("tr");
+    let lt = langid!("lt");
+
+    let uppercase_greek = "ΙΕΣΥΣ ΧΡΙΣΤΟΣ"; // "IESUS CHRISTOS"
+    let lowercase_greek = "ιεσυς χριστος"; // "IESUS CHRISTOS"
+    assert_eq!(
+        case_mapping.uppercase_to_string(lowercase_greek, &root),
+        uppercase_greek
+    );
+    assert_eq!(
+        case_mapping.lowercase_to_string(uppercase_greek, &root),
+        lowercase_greek
+    );
+    assert_eq!(
+        case_mapping.fold_string(uppercase_greek),
+        case_mapping.fold_string(lowercase_greek)
+    );
+
+    let lowercase_turkish_1 = "istanbul, not constantınople";
+    let uppercase_turkish_1 = "İSTANBUL, NOT CONSTANTINOPLE";
+    assert_eq!(
+        case_mapping.lowercase_to_string(uppercase_turkish_1, &root),
+        "i\u{307}stanbul, not constantinople"
+    );
+    assert_eq!(
+        case_mapping.lowercase_to_string(uppercase_turkish_1, &tr),
+        lowercase_turkish_1
+    );
+
+    let lowercase_turkish_2 = "topkapı palace, istanbul";
+    let uppercase_turkish_2 = "TOPKAPI PALACE, İSTANBUL";
+    assert_eq!(
+        case_mapping.uppercase_to_string(lowercase_turkish_2, &root),
+        "TOPKAPI PALACE, ISTANBUL"
+    );
+    assert_eq!(
+        case_mapping.uppercase_to_string(lowercase_turkish_2, &tr),
+        uppercase_turkish_2
+    );
+
+    let initial_german = "Süßmayrstraße";
+    let uppercase_german = "SÜSSMAYRSTRASSE";
+    assert_eq!(
+        case_mapping.uppercase_to_string(initial_german, &root),
+        uppercase_german
+    );
+
+    let before = "aBIΣßΣ/\u{5ffff}";
+    let after = "abiσßς/\u{5ffff}";
+    let after_turkish = "abıσßς/\u{5ffff}";
+    assert_eq!(case_mapping.lowercase_to_string(before, &root), after);
+    assert_eq!(case_mapping.lowercase_to_string(before, &tr), after_turkish);
+
+    let before = "aBiςßσ/\u{fb03}\u{fb03}\u{fb03}\u{5ffff}";
+    let after = "ABIΣSSΣ/FFIFFIFFI\u{5ffff}";
+    let after_turkish = "ABİΣSSΣ/FFIFFIFFI\u{5ffff}";
+    assert_eq!(case_mapping.uppercase_to_string(before, &root), after);
+    assert_eq!(case_mapping.uppercase_to_string(before, &tr), after_turkish);
+
+    let before = "ßa";
+    let after = "SSA";
+    assert_eq!(case_mapping.uppercase_to_string(before, &root), after);
+
+    let initial_deseret = "\u{1043c}\u{10414}";
+    let upper_deseret = "\u{10414}\u{10414}";
+    let lower_deseret = "\u{1043c}\u{1043c}";
+    assert_eq!(
+        case_mapping.uppercase_to_string(initial_deseret, &root),
+        upper_deseret
+    );
+    assert_eq!(
+        case_mapping.lowercase_to_string(initial_deseret, &root),
+        lower_deseret
+    );
+
+    // lj ligature
+    let initial_ligature = "\u{1c7}\u{1c8}\u{1c9}";
+    let lower_ligature = "\u{1c9}\u{1c9}\u{1c9}";
+    let upper_ligature = "\u{1c7}\u{1c7}\u{1c7}";
+    assert_eq!(
+        case_mapping.uppercase_to_string(initial_ligature, &root),
+        upper_ligature
+    );
+    assert_eq!(
+        case_mapping.lowercase_to_string(initial_ligature, &root),
+        lower_ligature
+    );
+
+    // Sigmas preceded and/or followed by cased letters
+    let initial_sigmas = "i\u{307}\u{3a3}\u{308}j \u{307}\u{3a3}\u{308}j i\u{ad}\u{3a3}\u{308} \u{307}\u{3a3}\u{308}";
+    let lower_sigmas = "i\u{307}\u{3c3}\u{308}j \u{307}\u{3c3}\u{308}j i\u{ad}\u{3c2}\u{308} \u{307}\u{3c3}\u{308}";
+    let upper_sigmas = "I\u{307}\u{3a3}\u{308}J \u{307}\u{3a3}\u{308}J I\u{ad}\u{3a3}\u{308} \u{307}\u{3a3}\u{308}";
+    assert_eq!(
+        case_mapping.uppercase_to_string(initial_sigmas, &root),
+        upper_sigmas
+    );
+    assert_eq!(
+        case_mapping.lowercase_to_string(initial_sigmas, &root),
+        lower_sigmas
+    );
+
+    // Turkish & Azerbaijani dotless i & dotted I:
+    // Remove dot above if there was a capital I before and there are no more accents above.
+    let initial_dots = "I İ I\u{307} I\u{327}\u{307} I\u{301}\u{307} I\u{327}\u{307}\u{301}";
+    let after = "i i\u{307} i\u{307} i\u{327}\u{307} i\u{301}\u{307} i\u{327}\u{307}\u{301}";
+    let after_turkish = "ı i i i\u{327} ı\u{301}\u{307} i\u{327}\u{301}";
+    assert_eq!(case_mapping.lowercase_to_string(initial_dots, &root), after);
+    assert_eq!(
+        case_mapping.lowercase_to_string(initial_dots, &tr),
+        after_turkish
+    );
+
+    // Lithuanian dot above in uppercasing
+    let initial_dots = "a\u{307} \u{307} i\u{307} j\u{327}\u{307} j\u{301}\u{307}";
+    let after = "A\u{307} \u{307} I\u{307} J\u{327}\u{307} J\u{301}\u{307}";
+    let after_lithuanian = "A\u{307} \u{307} I J\u{327} J\u{301}\u{307}";
+    assert_eq!(case_mapping.uppercase_to_string(initial_dots, &root), after);
+    assert_eq!(
+        case_mapping.uppercase_to_string(initial_dots, &lt),
+        after_lithuanian
+    );
+
+    // Lithuanian adds dot above to i in lowercasing if there are more above accents
+    let initial_dots = "I I\u{301} J J\u{301} \u{12e} \u{12e}\u{301} \u{cc}\u{cd}\u{128}";
+    let after = "i i\u{301} j j\u{301} \u{12f} \u{12f}\u{301} \u{ec}\u{ed}\u{129}";
+    let after_lithuanian = "i i\u{307}\u{301} j j\u{307}\u{301} \u{12f} \u{12f}\u{307}\u{301} i\u{307}\u{300}i\u{307}\u{301}i\u{307}\u{303}";
+    assert_eq!(case_mapping.lowercase_to_string(initial_dots, &root), after);
+    assert_eq!(
+        case_mapping.lowercase_to_string(initial_dots, &lt),
+        after_lithuanian
+    );
+
+    // Test case folding
+    let initial = "Aßµ\u{fb03}\u{1040c}İı";
+    let simple = "assμffi\u{10434}i\u{307}ı";
+    let turkic = "assμffi\u{10434}iı";
+    assert_eq!(case_mapping.fold_string(initial), simple);
+    assert_eq!(case_mapping.fold_turkic_string(initial), turkic);
+}
+
+#[test]
+fn test_armenian() {
+    let cm = CaseMapper::new();
+    let root = langid!("und");
+    let east = langid!("hy");
+    let west = langid!("hyw");
+    let default_options = Default::default();
+
+    let s = "և Երևանի";
+
+    assert_eq!(cm.uppercase_to_string(s, &root), "ԵՒ ԵՐԵՒԱՆԻ");
+    assert_eq!(cm.uppercase_to_string(s, &east), "ԵՎ ԵՐԵՎԱՆԻ");
+    assert_eq!(cm.uppercase_to_string(s, &west), "ԵՒ ԵՐԵՒԱՆԻ");
+
+    let ew = "և";
+    let yerevan = "Երևանի";
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string(ew, &root, default_options),
+        "Եւ"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string(yerevan, &root, default_options),
+        "Երևանի"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string(ew, &east, default_options),
+        "Եվ"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string(yerevan, &east, default_options),
+        "Երևանի"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string(ew, &west, default_options),
+        "Եւ"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string(yerevan, &west, default_options),
+        "Երևանի"
+    );
+}
+
+#[test]
+fn test_dutch() {
+    let cm = CaseMapper::new();
+    let nl = langid!("nl");
+    let default_options = Default::default();
+
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ijssel", &nl, default_options),
+        "IJssel"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("igloo", &nl, default_options),
+        "Igloo"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("IJMUIDEN", &nl, default_options),
+        "IJmuiden"
+    );
+
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ij", &nl, default_options),
+        "IJ"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("IJ", &nl, default_options),
+        "IJ"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íj́", &nl, default_options),
+        "ÍJ́"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ÍJ́", &nl, default_options),
+        "ÍJ́"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íJ́", &nl, default_options),
+        "ÍJ́"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("Ij́", &nl, default_options),
+        "Ij́"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ij́", &nl, default_options),
+        "Ij́"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ïj́", &nl, default_options),
+        "Ïj́"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íj\u{0308}", &nl, default_options),
+        "Íj\u{0308}"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íj́\u{1D16E}", &nl, default_options),
+        "Íj́\u{1D16E}"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íj\u{1ABE}", &nl, default_options),
+        "Íj\u{1ABE}"
+    );
+
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ijabc", &nl, default_options),
+        "IJabc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("IJabc", &nl, default_options),
+        "IJabc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íj́abc", &nl, default_options),
+        "ÍJ́abc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ÍJ́abc", &nl, default_options),
+        "ÍJ́abc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íJ́abc", &nl, default_options),
+        "ÍJ́abc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("Ij́abc", &nl, default_options),
+        "Ij́abc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ij́abc", &nl, default_options),
+        "Ij́abc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("ïj́abc", &nl, default_options),
+        "Ïj́abc"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íjabc\u{0308}", &nl, default_options),
+        "Íjabc\u{0308}"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íj́abc\u{1D16E}", &nl, default_options),
+        "ÍJ́abc\u{1D16E}"
+    );
+    assert_eq!(
+        cm.titlecase_segment_with_only_case_data_to_string("íjabc\u{1ABE}", &nl, default_options),
+        "Íjabc\u{1ABE}"
+    );
+}
+
+#[test]
+fn test_greek_upper() {
+    let nfc = icu_normalizer::ComposingNormalizerBorrowed::new_nfc();
+    let nfd = icu_normalizer::DecomposingNormalizerBorrowed::new_nfd();
+
+    let cm = CaseMapper::new();
+    let modern_greek = &langid!("el");
+
+    let assert_greek_uppercase = |input: &str, expected: &str| {
+        assert_eq!(
+            cm.uppercase_to_string(nfc.normalize(input).as_ref(), modern_greek),
+            nfc.normalize(expected)
+        );
+        assert_eq!(
+            cm.uppercase_to_string(nfd.normalize(input).as_ref(), modern_greek),
+            nfd.normalize(expected)
+        );
+    };
+
+    // https://unicode-org.atlassian.net/browse/ICU-5456
+    assert_greek_uppercase("άδικος, κείμενο, ίριδα", "ΑΔΙΚΟΣ, ΚΕΙΜΕΝΟ, ΙΡΙΔΑ");
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=307039
+    // https://bug307039.bmoattachments.org/attachment.cgi?id=194893
+    assert_greek_uppercase("Πατάτα", "ΠΑΤΑΤΑ");
+    assert_greek_uppercase("Αέρας, Μυστήριο, Ωραίο", "ΑΕΡΑΣ, ΜΥΣΤΗΡΙΟ, ΩΡΑΙΟ");
+    assert_greek_uppercase("Μαΐου, Πόρος, Ρύθμιση", "ΜΑΪΟΥ, ΠΟΡΟΣ, ΡΥΘΜΙΣΗ");
+    assert_greek_uppercase("ΰ, Τηρώ, Μάιος", "Ϋ, ΤΗΡΩ, ΜΑΪΟΣ");
+    assert_greek_uppercase("άυλος", "ΑΫΛΟΣ");
+    assert_greek_uppercase("ΑΫΛΟΣ", "ΑΫΛΟΣ");
+    assert_greek_uppercase(
+        "Άκλιτα ρήματα ή άκλιτες μετοχές",
+        "ΑΚΛΙΤΑ ΡΗΜΑΤΑ Ή ΑΚΛΙΤΕΣ ΜΕΤΟΧΕΣ",
+    );
+    // http://www.unicode.org/udhr/d/udhr_ell_monotonic.html
+    assert_greek_uppercase(
+        "Επειδή η αναγνώριση της αξιοπρέπειας",
+        "ΕΠΕΙΔΗ Η ΑΝΑΓΝΩΡΙΣΗ ΤΗΣ ΑΞΙΟΠΡΕΠΕΙΑΣ",
+    );
+    assert_greek_uppercase("νομικού ή διεθνούς", "ΝΟΜΙΚΟΥ Ή ΔΙΕΘΝΟΥΣ");
+    // http://unicode.org/udhr/d/udhr_ell_polytonic.html
+    assert_greek_uppercase("Ἐπειδὴ ἡ ἀναγνώριση", "ΕΠΕΙΔΗ Η ΑΝΑΓΝΩΡΙΣΗ");
+    assert_greek_uppercase("νομικοῦ ἢ διεθνοῦς", "ΝΟΜΙΚΟΥ Ή ΔΙΕΘΝΟΥΣ");
+    // From Google bug report
+    assert_greek_uppercase("Νέο, Δημιουργία", "ΝΕΟ, ΔΗΜΙΟΥΡΓΙΑ");
+    // http://crbug.com/234797
+    assert_greek_uppercase(
+        "Ελάτε να φάτε τα καλύτερα παϊδάκια!",
+        "ΕΛΑΤΕ ΝΑ ΦΑΤΕ ΤΑ ΚΑΛΥΤΕΡΑ ΠΑΪΔΑΚΙΑ!",
+    );
+    assert_greek_uppercase("Μαΐου, τρόλεϊ", "ΜΑΪΟΥ, ΤΡΟΛΕΪ");
+    assert_greek_uppercase("Το ένα ή το άλλο.", "ΤΟ ΕΝΑ Ή ΤΟ ΑΛΛΟ.");
+    // http://multilingualtypesetting.co.uk/blog/greek-typesetting-tips/
+    assert_greek_uppercase("ρωμέικα", "ΡΩΜΕΪΚΑ");
+    assert_greek_uppercase("ή.", "Ή.");
+
+    // The ὑπογεγραμμέναι become Ι as in default case conversion, but they are
+    // specially handled by the implementation.
+    assert_greek_uppercase("ᾠδή, -ήν, -ῆς, -ῇ", "ΩΙΔΗ, -ΗΝ, -ΗΣ, -ΗΙ");
+    assert_greek_uppercase("ᾍδης", "ΑΙΔΗΣ");
+
+    // Handle breathing marks on rho
+    assert_greek_uppercase("ῥήματα ῤήματα", "ΡΗΜΑΤΑ ΡΗΜΑΤΑ");
+}
diff --git a/third_party/rust/icu_casemap/tests/gen_greek_to_me.rs b/third_party/rust/icu_casemap/tests/gen_greek_to_me.rs
@@ -0,0 +1,202 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use icu_casemap::greek_to_me::{
+    self, GreekDiacritics, GreekPrecomposedLetterData, GreekVowel, PackedGreekPrecomposedLetterData,
+};
+use icu_casemap::CaseMapper;
+use icu_locale_core::LanguageIdentifier;
+use icu_normalizer::DecomposingNormalizerBorrowed;
+use icu_properties::{
+    props::{GeneralCategory, GeneralCategoryGroup, Script},
+    CodePointMapData,
+};
+use std::collections::BTreeMap;
+use std::fmt::Write;
+
+fn main() {
+    let decomposer = DecomposingNormalizerBorrowed::new_nfd();
+    let script = CodePointMapData::<Script>::new();
+    let gc = CodePointMapData::<GeneralCategory>::new();
+    let cm = CaseMapper::new();
+
+    let mut vec_370 = vec![0; 0x400 - 0x370];
+    let mut vec_1f00 = vec![0; 0x100];
+    let mut extras = BTreeMap::new();
+
+    // Loop over all codepoints
+    for range in script.iter_ranges_for_value(Script::Greek) {
+        for ch in range {
+            if let Ok(ch) = char::try_from(ch) {
+                if !GeneralCategoryGroup::Letter.contains(gc.get(ch)) {
+                    continue;
+                }
+                let mut buf = [0u8; 4];
+                let nfd = decomposer.normalize_utf8(ch.encode_utf8(&mut buf).as_bytes());
+                let mut data: Option<GreekPrecomposedLetterData> = None;
+
+                for nfd_ch in nfd.chars() {
+                    match nfd_ch {
+                        // accented: [:toNFD=/[\u0300\u0301\u0342\u0302\u0303\u0311]/:]&[:Grek:]&[:L:] (from the JSPs: toNFD is an extension).
+                        greek_to_me::diacritics!(ACCENTS) => {
+                            if let Some(GreekPrecomposedLetterData::Vowel(_, ref mut diacritics)) =
+                                data
+                            {
+                                diacritics.accented = true;
+                            } else {
+                                panic!("Found character {ch} that has diacritics but is not a Greek vowel");
+                            }
+                        }
+                        // dialytika: [:toNFD=/[\u0308]/:]&[:Grek:]&[:L:] (from the JSPs: toNFD is an extension).
+                        greek_to_me::diacritics!(DIALYTIKA) => {
+                            if let Some(GreekPrecomposedLetterData::Vowel(_, ref mut diacritics)) =
+                                data
+                            {
+                                diacritics.dialytika = true;
+                            } else {
+                                panic!("Found character {ch} that has diacritics but is not a Greek vowel");
+                            }
+                        }
+                        // precomposed_ypogegrammeni [:toNFD=/[\u0345]/:]&[:Grek:]&[:L:] (from the JSPs: toNFD is an extension).
+                        greek_to_me::diacritics!(YPOGEGRAMMENI) => {
+                            if let Some(GreekPrecomposedLetterData::Vowel(_, ref mut diacritics)) =
+                                data
+                            {
+                                diacritics.ypogegrammeni = true;
+                            } else {
+                                panic!("Found character {ch} that has diacritics but is not a Greek vowel");
+                            }
+                        }
+                        greek_to_me::diacritics!(BREATHING_AND_LENGTH)
+                        | greek_to_me::diacritics!(ACCENTS) => {
+                            // Rho takes breathing marks but other consonants should not
+                            if let Some(GreekPrecomposedLetterData::Consonant(false)) = data {
+                                panic!("Found character {ch} that has diacritics but is not a Greek vowel");
+                            }
+                        }
+                        // Ignore all small letters
+                        '\u{1D00}'..='\u{1DBF}' | '\u{AB65}' => (),
+                        // caps: [[:Grek:]&[:L:]-[\u1D00-\u1DBF\uAB65]] . NFD, remove non-letters, uppercase
+                        letter if GeneralCategoryGroup::Letter.contains(gc.get(letter)) => {
+                            let uppercased = cm
+                                .uppercase_to_string(
+                                    letter.encode_utf8(&mut [0; 4]),
+                                    &LanguageIdentifier::UNKNOWN,
+                                )
+                                .into_owned();
+                            let mut iter = uppercased.chars();
+                            let uppercased = iter.next().unwrap();
+                            assert!(
+                                iter.next().is_none(),
+                                "{letter} Should uppercase to a single letter char, instead uppercased to {uppercased:?}"
+                            );
+
+                            if let Ok(vowel) = GreekVowel::try_from(uppercased) {
+                                data = Some(GreekPrecomposedLetterData::Vowel(
+                                    vowel,
+                                    GreekDiacritics::default(),
+                                ))
+                            } else {
+                                let is_rho = uppercased == greek_to_me::CAPITAL_RHO;
+                                data = Some(GreekPrecomposedLetterData::Consonant(is_rho))
+                            };
+                        }
+                        _ => (),
+                    }
+                }
+
+                if let Some(data) = data {
+                    let packed = PackedGreekPrecomposedLetterData::from(data);
+                    assert_eq!(
+                        Ok(data),
+                        packed.try_into(),
+                        "packed data for {ch} ({packed:?}) must roundtrip!"
+                    );
+                    let ch_i = ch as usize;
+                    if (0x370..=0x3FF).contains(&ch_i) {
+                        vec_370[ch_i - 0x370] = packed.0;
+                    } else if (0x1f00..0x1fff).contains(&ch_i) {
+                        vec_1f00[ch_i - 0x1f00] = packed.0;
+                    } else {
+                        extras.insert(ch, packed.0);
+                    }
+                }
+            }
+        }
+    }
+
+    vec_370.truncate(
+        vec_370
+            .iter()
+            .rposition(|x| *x != 0)
+            .expect("must have some greek data")
+            + 1,
+    );
+    vec_1f00.truncate(
+        vec_1f00
+            .iter()
+            .rposition(|x| *x != 0)
+            .expect("must have some greek data")
+            + 1,
+    );
+
+    let mut others = String::new();
+    for (ch, data) in extras {
+        writeln!(&mut others, "        '{ch}' => {data},").unwrap();
+    }
+
+    let output = format!(
+        r#"// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+// This file is generated by running `cargo test --test gen_greek_to_me --features compiled_data,datagen
+//
+// Do not edit manually
+
+// All u8s in this file are PackedGreekPrecomposedLetterDatas, see parent module
+
+/// Data for characters in U+370-U+3FF
+pub(crate) const DATA_370: [u8; 0x{:x}] = {vec_370:?};
+/// Data for characters in U+1F00-U+1FFF
+pub(crate) const DATA_1F00: [u8; 0x{:x}] = {vec_1f00:?};
+
+/// Characters like the ohm sign that do not belong in the two blocks above
+pub(crate) fn match_extras(ch: char) -> Option<u8> {{
+    Some(match ch {{
+{others}
+        _ => return None
+    }})
+}}
+"#,
+        vec_370.len(),
+        vec_1f00.len(),
+    );
+
+    let local = include_str!("../src/greek_to_me/data.rs");
+
+    // We cannot just check if the two are unequal because on Windows core.autocrlf
+    // may have messed with the line endings on the file, or it may have not (either
+    // due to a changed setting, or due to the code being in a cargo cache/vendor. We also
+    // cannot fix this by passing `--config newline_style=unix` to rustfmt. We must
+    // perform a `\r`-agnostic comparison.
+    //
+    // (technically this should only catch `\r\n` and not just `\r` but for a golden
+    // test on rustfmt output it does not matter)
+    if local
+        .trim()
+        .chars()
+        .filter(|&x| x != '\r')
+        .ne(output.trim().chars().filter(|&x| x != '\r'))
+    {
+        println!(
+            r#"Please copy the following file to src/greek_to_me/data.rs:
+========================================================
+{output}
+========================================================"#
+        );
+
+        panic!("Found mismatch between generated Greek specialcasing data and checked-in data. Please check in the updated file shown above.");
+    }
+}
diff --git a/third_party/rust/icu_casemap_data/.cargo-checksum.json b/third_party/rust/icu_casemap_data/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"a454837cb960e971cb805ef9ede3f99ba01d8db524ea0b964b1cba68a35dc99e","Cargo.toml":"1e290046e5e2998d17e45837b7dc55211186d6aa9e0791bf697d1c7cfe679d21","LICENSE":"f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2","README.md":"a6f8491c503c28b48259861afbabc36d62b7cbd9261637e5501a84a16b1bffc4","build.rs":"c2d446772e3d766a804963dbf36e51729f910920f91f4b68c0c199fe6ca0853e","data/case_map_unfold_v1.rs.data":"6db70cadb6e0823de95f405705b80fcdd9a25f0e1f390dcf37ed462c7c52c6e4","data/case_map_v1.rs.data":"5d3c6b39f4ec97877998e60f25ea289046d1348cc7c9b02a1b955cad5b25da23","data/mod.rs":"e73b3a6a6e31af95d0e81c8bf06f19ce9e46bc3f04bb57c4482fe07fada686af","src/lib.rs":"84c2bfb178cc3b91864bbb6821b84838007360e6e5b947387c362488069dcda4"},"package":"f7584067558ab4c60c95d1ac2abd1588689cb4bcd4e099507f62dae86ae8d2c0"}
+\ No newline at end of file
diff --git a/third_party/rust/icu_casemap_data/Cargo.lock b/third_party/rust/icu_casemap_data/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "icu_casemap_data"
+version = "2.0.0"
diff --git a/third_party/rust/icu_casemap_data/Cargo.toml b/third_party/rust/icu_casemap_data/Cargo.toml
@@ -0,0 +1,60 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.82"
+name = "icu_casemap_data"
+version = "2.0.0"
+authors = ["The ICU4X Project Developers"]
+build = "build.rs"
+include = [
+    "data/**/*",
+    "src/**/*",
+    "examples/**/*",
+    "benches/**/*",
+    "tests/**/*",
+    "Cargo.toml",
+    "LICENSE",
+    "README.md",
+    "build.rs",
+]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Data for the icu_casemap crate"
+homepage = "https://icu4x.unicode.org"
+readme = "README.md"
+categories = ["internationalization"]
+license = "Unicode-3.0"
+repository = "https://github.com/unicode-org/icu4x"
+
+[package.metadata.sources.cldr]
+tagged = "47.0.0"
+
+[package.metadata.sources.icuexport]
+tagged = "icu4x/2025-05-01/77.x"
+
+[package.metadata.sources.segmenter_lstm]
+tagged = "v0.1.0"
+
+[lib]
+name = "icu_casemap_data"
+path = "src/lib.rs"
+
+[dependencies]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0
+check-cfg = ["cfg(icu4x_custom_data)"]
diff --git a/third_party/rust/icu_casemap_data/LICENSE b/third_party/rust/icu_casemap_data/LICENSE
@@ -0,0 +1,46 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2020-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0
+
+—
+
+Portions of ICU4X may have been adapted from ICU4C and/or ICU4J.
+ICU 1.8.1 to ICU 57.1 © 1995-2016 International Business Machines Corporation and others.
diff --git a/third_party/rust/icu_casemap_data/README.md b/third_party/rust/icu_casemap_data/README.md
@@ -0,0 +1,14 @@
+# icu_casemap_data [![crates.io](https://img.shields.io/crates/v/icu_casemap_data)](https://crates.io/crates/icu_casemap_data)
+
+<!-- cargo-rdme start -->
+
+Data for the `icu_casemap` crate
+
+This data was generated with CLDR version 47.0.0, ICU version icu4x/2025-05-01/77.x, and
+LSTM segmenter version v0.1.0.
+
+<!-- cargo-rdme end -->
+
+## More Information
+
+For more information on development, authorship, contributing etc. please visit [`ICU4X home page`](https://github.com/unicode-org/icu4x).
diff --git a/third_party/rust/icu_casemap_data/build.rs b/third_party/rust/icu_casemap_data/build.rs
@@ -0,0 +1,11 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+fn main() {
+    if std::env::var("ICU4X_DATA_DIR").is_ok() {
+        println!("cargo:rustc-cfg=icu4x_custom_data");
+    }
+    println!("cargo:rerun-if-env-changed=ICU4X_DATA_DIR");
+    println!("cargo:rustc-check-cfg=cfg(icu4c_enable_renaming)");
+}
diff --git a/third_party/rust/icu_casemap_data/data/case_map_unfold_v1.rs.data b/third_party/rust/icu_casemap_data/data/case_map_unfold_v1.rs.data
@@ -0,0 +1,80 @@
+// @generated
+/// Implement `DataProvider<CaseMapUnfoldV1>` on the given struct using the data
+/// hardcoded in this file. This allows the struct to be used with
+/// `icu`'s `_unstable` constructors.
+///
+/// Using this implementation will embed the following data in the binary's data segment:
+/// * 968B[^1] for the singleton data struct
+///
+/// [^1]: these numbers can be smaller in practice due to linker deduplication
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __impl_case_map_unfold_v1 {
+    ($ provider : ty) => {
+        #[clippy::msrv = "1.82"]
+        const _: () = <$provider>::MUST_USE_MAKE_PROVIDER_MACRO;
+        #[clippy::msrv = "1.82"]
+        impl $provider {
+            #[doc(hidden)]
+            pub const SINGLETON_CASE_MAP_UNFOLD_V1: &'static <icu::casemap::provider::CaseMapUnfoldV1 as icu_provider::DynamicDataMarker>::DataStruct = &icu::casemap::provider::CaseMapUnfold {
+                map: unsafe {
+                    #[allow(unused_unsafe)]
+                    zerovec::ZeroMap::from_parts_unchecked(unsafe { zerovec::vecs::VarZeroVec16::from_bytes_unchecked(b"I\0\x03\0\x05\0\x08\0\x0B\0\r\0\x0F\0\x12\0\x15\0\x18\0\x1A\0\x1C\0\x1F\0\"\0%\0(\0,\x000\x004\0:\0>\0B\0H\0L\0R\0X\0^\0b\0f\0l\0r\0x\0|\0\x82\0\x88\0\x8E\0\x92\0\x96\0\x9C\0\xA0\0\xA4\0\xA8\0\xAC\0\xB0\0\xB4\0\xB8\0\xBC\0\xC1\0\xC6\0\xCB\0\xD0\0\xD5\0\xDA\0\xDF\0\xE4\0\xE9\0\xEE\0\xF3\0\xF8\0\xFD\0\x02\x01\x07\x01\x0C\x01\x11\x01\x16\x01\x1B\x01 \x01%\x01*\x01/\x014\x019\x01>\x01a\xCA\xBEffffifflfiflh\xCC\xB1i\xCC\x87j\xCC\x8Cssstt\xCC\x88w\xCC\x8Ay\xCC\x8A\xCA\xBCn\xCE\xAC\xCE\xB9\xCE\xAE\xCE\xB9\xCE\xB1\xCD\x82\xCE\xB1\xCD\x82\xCE\xB9\xCE\xB1\xCE\xB9\xCE\xB7\xCD\x82\xCE\xB7\xCD\x82\xCE\xB9\xCE\xB7\xCE\xB9\xCE\xB9\xCC\x88\xCC\x80\xCE\xB9\xCC\x88\xCC\x81\xCE\xB9\xCC\x88\xCD\x82\xCE\xB9\xCD\x82\xCF\x81\xCC\x93\xCF\x85\xCC\x88\xCC\x80\xCF\x85\xCC\x88\xCC\x81\xCF\x85\xCC\x88\xCD\x82\xCF\x85\xCC\x93\xCF\x85\xCC\x93\xCC\x80\xCF\x85\xCC\x93\xCC\x81\xCF\x85\xCC\x93\xCD\x82\xCF\x85\xCD\x82\xCF\x89\xCD\x82\xCF\x89\xCD\x82\xCE\xB9\xCF\x89\xCE\xB9\xCF\x8E\xCE\xB9\xD5\xA5\xD6\x82\xD5\xB4\xD5\xA5\xD5\xB4\xD5\xAB\xD5\xB4\xD5\xAD\xD5\xB4\xD5\xB6\xD5\xBE\xD5\xB6\xE1\xBC\x80\xCE\xB9\xE1\xBC\x81\xCE\xB9\xE1\xBC\x82\xCE\xB9\xE1\xBC\x83\xCE\xB9\xE1\xBC\x84\xCE\xB9\xE1\xBC\x85\xCE\xB9\xE1\xBC\x86\xCE\xB9\xE1\xBC\x87\xCE\xB9\xE1\xBC\xA0\xCE\xB9\xE1\xBC\xA1\xCE\xB9\xE1\xBC\xA2\xCE\xB9\xE1\xBC\xA3\xCE\xB9\xE1\xBC\xA4\xCE\xB9\xE1\xBC\xA5\xCE\xB9\xE1\xBC\xA6\xCE\xB9\xE1\xBC\xA7\xCE\xB9\xE1\xBD\xA0\xCE\xB9\xE1\xBD\xA1\xCE\xB9\xE1\xBD\xA2\xCE\xB9\xE1\xBD\xA3\xCE\xB9\xE1\xBD\xA4\xCE\xB9\xE1\xBD\xA5\xCE\xB9\xE1\xBD\xA6\xCE\xB9\xE1\xBD\xA7\xCE\xB9\xE1\xBD\xB0\xCE\xB9\xE1\xBD\xB4\xCE\xB9\xE1\xBD\xBC\xCE\xB9") }, unsafe { zerovec::vecs::VarZeroVec16::from_bytes_unchecked(b"I\0\x03\0\x06\0\t\0\x0C\0\x0F\0\x12\0\x15\0\x17\0\x19\0\x1E\0$\0'\0*\0-\0/\x002\x005\08\0;\0A\0D\0G\0M\0P\0U\0X\0[\0^\0a\0f\0i\0l\0o\0r\0u\0x\0{\0~\0\x84\0\x87\0\x89\0\x8C\0\x8F\0\x92\0\x95\0\x98\0\x9E\0\xA4\0\xAA\0\xB0\0\xB6\0\xBC\0\xC2\0\xC8\0\xCE\0\xD4\0\xDA\0\xE0\0\xE6\0\xEC\0\xF2\0\xF8\0\xFE\0\x04\x01\n\x01\x10\x01\x16\x01\x1C\x01\"\x01(\x01+\x01.\x01\xE1\xBA\x9A\xEF\xAC\x80\xEF\xAC\x83\xEF\xAC\x84\xEF\xAC\x81\xEF\xAC\x82\xE1\xBA\x96\xC4\xB0\xC7\xB0\xC3\x9F\xE1\xBA\x9E\xEF\xAC\x85\xEF\xAC\x86\xE1\xBA\x97\xE1\xBA\x98\xE1\xBA\x99\xC5\x89\xE1\xBE\xB4\xE1\xBF\x84\xE1\xBE\xB6\xE1\xBE\xB7\xE1\xBE\xB3\xE1\xBE\xBC\xE1\xBF\x86\xE1\xBF\x87\xE1\xBF\x83\xE1\xBF\x8C\xE1\xBF\x92\xCE\x90\xE1\xBF\x93\xE1\xBF\x97\xE1\xBF\x96\xE1\xBF\xA4\xE1\xBF\xA2\xCE\xB0\xE1\xBF\xA3\xE1\xBF\xA7\xE1\xBD\x90\xE1\xBD\x92\xE1\xBD\x94\xE1\xBD\x96\xE1\xBF\xA6\xE1\xBF\xB6\xE1\xBF\xB7\xE1\xBF\xB3\xE1\xBF\xBC\xE1\xBF\xB4\xD6\x87\xEF\xAC\x94\xEF\xAC\x95\xEF\xAC\x97\xEF\xAC\x93\xEF\xAC\x96\xE1\xBE\x80\xE1\xBE\x88\xE1\xBE\x81\xE1\xBE\x89\xE1\xBE\x82\xE1\xBE\x8A\xE1\xBE\x83\xE1\xBE\x8B\xE1\xBE\x84\xE1\xBE\x8C\xE1\xBE\x85\xE1\xBE\x8D\xE1\xBE\x86\xE1\xBE\x8E\xE1\xBE\x87\xE1\xBE\x8F\xE1\xBE\x90\xE1\xBE\x98\xE1\xBE\x91\xE1\xBE\x99\xE1\xBE\x92\xE1\xBE\x9A\xE1\xBE\x93\xE1\xBE\x9B\xE1\xBE\x94\xE1\xBE\x9C\xE1\xBE\x95\xE1\xBE\x9D\xE1\xBE\x96\xE1\xBE\x9E\xE1\xBE\x97\xE1\xBE\x9F\xE1\xBE\xA0\xE1\xBE\xA8\xE1\xBE\xA1\xE1\xBE\xA9\xE1\xBE\xA2\xE1\xBE\xAA\xE1\xBE\xA3\xE1\xBE\xAB\xE1\xBE\xA4\xE1\xBE\xAC\xE1\xBE\xA5\xE1\xBE\xAD\xE1\xBE\xA6\xE1\xBE\xAE\xE1\xBE\xA7\xE1\xBE\xAF\xE1\xBE\xB2\xE1\xBF\x82\xE1\xBF\xB2") })
+                },
+            };
+        }
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::DataProvider<icu::casemap::provider::CaseMapUnfoldV1> for $provider {
+            fn load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponse<icu::casemap::provider::CaseMapUnfoldV1>, icu_provider::DataError> {
+                if req.id.locale.is_unknown() {
+                    Ok(icu_provider::DataResponse { payload: icu_provider::DataPayload::from_static_ref(Self::SINGLETON_CASE_MAP_UNFOLD_V1), metadata: icu_provider::DataResponseMetadata::default() })
+                } else {
+                    Err(icu_provider::DataErrorKind::InvalidRequest.with_req(<icu::casemap::provider::CaseMapUnfoldV1 as icu_provider::DataMarker>::INFO, req))
+                }
+            }
+        }
+    };
+    ($ provider : ty , ITER) => {
+        __impl_case_map_unfold_v1!($provider);
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::IterableDataProvider<icu::casemap::provider::CaseMapUnfoldV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BtreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok([Default::default()].into_iter().collect())
+            }
+        }
+    };
+    ($ provider : ty , DRY) => {
+        __impl_case_map_unfold_v1!($provider);
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::DryDataProvider<icu::casemap::provider::CaseMapUnfoldV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                if req.id.locale.is_unknown() {
+                    Ok(icu_provider::DataResponseMetadata::default())
+                } else {
+                    Err(icu_provider::DataErrorKind::InvalidRequest.with_req(<icu::casemap::provider::CaseMapUnfoldV1 as icu_provider::DataMarker>::INFO, req))
+                }
+            }
+        }
+    };
+    ($ provider : ty , DRY , ITER) => {
+        __impl_case_map_unfold_v1!($provider);
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::DryDataProvider<icu::casemap::provider::CaseMapUnfoldV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                if req.id.locale.is_unknown() {
+                    Ok(icu_provider::DataResponseMetadata::default())
+                } else {
+                    Err(icu_provider::DataErrorKind::InvalidRequest.with_req(<icu::casemap::provider::CaseMapUnfoldV1 as icu_provider::DataMarker>::INFO, req))
+                }
+            }
+        }
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::IterableDataProvider<icu::casemap::provider::CaseMapUnfoldV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BtreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok([Default::default()].into_iter().collect())
+            }
+        }
+    };
+}
+#[doc(inline)]
+pub use __impl_case_map_unfold_v1 as impl_case_map_unfold_v1;
diff --git a/third_party/rust/icu_casemap_data/data/case_map_v1.rs.data b/third_party/rust/icu_casemap_data/data/case_map_v1.rs.data
@@ -0,0 +1,75 @@
+// @generated
+/// Implement `DataProvider<CaseMapV1>` on the given struct using the data
+/// hardcoded in this file. This allows the struct to be used with
+/// `icu`'s `_unstable` constructors.
+///
+/// Using this implementation will embed the following data in the binary's data segment:
+/// * 22731B[^1] for the singleton data struct
+///
+/// [^1]: these numbers can be smaller in practice due to linker deduplication
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __impl_case_map_v1 {
+    ($ provider : ty) => {
+        #[clippy::msrv = "1.82"]
+        const _: () = <$provider>::MUST_USE_MAKE_PROVIDER_MACRO;
+        #[clippy::msrv = "1.82"]
+        impl $provider {
+            #[doc(hidden)]
+            pub const SINGLETON_CASE_MAP_V1: &'static <icu::casemap::provider::CaseMapV1 as icu_provider::DynamicDataMarker>::DataStruct = &icu::casemap::provider::CaseMap { trie: icu::collections::codepointtrie::CodePointTrie::from_parts(icu::collections::codepointtrie::CodePointTrieHeader { high_start: 918016u32, shifted12_high_start: 225u16, index3_null_offset: 425u16, data_null_offset: 1552u32, null_value: 0u32, trie_type: icu::collections::codepointtrie::TrieType::Small }, unsafe { zerovec::ZeroVec::from_bytes_unchecked(b"\0\0@\0{\0\xBB\0\xFB\x005\x01u\x01\xB5\x01\xED\x01,\x02l\x02\xAC\x02\xEC\x02*\x03j\x03\xAA\x03\xEA\x03)\x04g\x04\xA7\x04\xB7\x04\xE8\x04!\x05_\x05\x9F\x05\xDF\x05\x10\x06:\x06k\x06\xAA\x06\xC4\x06\xF5\x063\x07a\x07\x99\x07\xD0\x07\x10\x08O\x08\x7F\x08\xBE\x08\xFD\x08<\t\xFD\x08{\t\xBB\t\xF9\t7\nw\n\xB7\n\xF6\n\xBB\t0\x0BR\x0B\x91\x0B\xD0\x0B\x06\x0C\x1D\x0CX\x0Cg\x0C\xA4\x0C\xCC\x0C\x06\rF\r\t\x06\x91\x07\xAA\x07\xBA\x07\xD0\x07\xF0\x07\x0B\x08#\x08B\x08\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xAA\x07\xFE\0\0\0\x10\0 \x000\0@\0P\0`\0p\0{\0\x8B\0\x9B\0\xAB\0\xBB\0\xCB\0\xDB\0\xEB\0\xFB\0\x0B\x01\x1B\x01+\x015\x01E\x01U\x01e\x01u\x01\x85\x01\x95\x01\xA5\x01\xB5\x01\xC5\x01\xD5\x01\xE5\x01\xED\x01\xFD\x01\r\x02\x1D\x02,\x02<\x02L\x02\\\x02l\x02|\x02\x8C\x02\x9C\x02\xAC\x02\xBC\x02\xCC\x02\xDC\x02\xEC\x02\xFC\x02\x0C\x03\x1C\x03*\x03:\x03J\x03Z\x03j\x03z\x03\x8A\x03\x9A\x03\xAA\x03\xBA\x03\xCA\x03\xDA\x03\xEA\x03\xFA\x03\n\x04\x1A\x04)\x049\x04I\x04Y\x04g\x04w\x04\x87\x04\x97\x04\xA7\x04\xB7\x04\xC7\x04\xD7\x04\xB7\x04\xC7\x04\xD7\x04\xE7\x04\xE8\x04\xF8\x04\x08\x05\x18\x05!\x051\x05A\x05Q\x05_\x05o\x05\x7F\x05\x8F\x05\x9F\x05\xAF\x05\xBF\x05\xCF\x05\xDF\x05\xEF\x05\xFF\x05\x0F\x06\x10\x06 \x060\x06@\x06:\x06J\x06Z\x06j\x06k\x06{\x06\x8B\x06\x9B\x06\xAA\x06\xBA\x06\xCA\x06\xDA\x06\xC4\x06\xD4\x06\xE4\x06\xF4\x06\xF5\x06\x05\x07\x15\x07%\x073\x07C\x07S\x07c\x07a\x07q\x07\x81\x07\x91\x07\x99\x07\xA9\x07\xB9\x07\xC9\x07\xD0\x07\xE0\x07\xF0\x07\0\x08\x10\x08 \x080\x08@\x08O\x08_\x08o\x08\x7F\x08\x7F\x08\x8F\x08\x9F\x08\xAF\x08\xBE\x08\xCE\x08\xDE\x08\xEE\x08\xFD\x08\r\t\x1D\t-\t<\tL\t\\\tl\t\xFD\x08\r\t\x1D\t-\t{\t\x8B\t\x9B\t\xAB\t\xBB\t\xCB\t\xDB\t\xEB\t\xF9\t\t\n\x19\n)\n7\nG\nW\ng\nw\n\x87\n\x97\n\xA7\n\xB7\n\xC7\n\xD7\n\xE7\n\xF6\n\x06\x0B\x16\x0B&\x0B\xBB\t\xCB\t\xDB\t\xEB\t0\x0B@\x0BP\x0B`\x0BR\x0Bb\x0Br\x0B\x82\x0B\x91\x0B\xA1\x0B\xB1\x0B\xC1\x0B\xD0\x0B\xE0\x0B\xF0\x0B\0\x0C\x06\x0C\x16\x0C&\x0C6\x0C\x1D\x0C-\x0C=\x0CM\x0CX\x0Ch\x0Cx\x0C\x88\x0Cg\x0Cw\x0C\x87\x0C\x97\x0C\xA4\x0C\xB4\x0C\xC4\x0C\xD4\x0C\xCC\x0C\xDC\x0C\xEC\x0C\xFC\x0C\x06\r\x16\r&\r6\rF\rV\rf\rv\r\t\x06\x19\x06)\x069\x06\x10\x06\x10\x06\xDD\x06\x86\r\x10\x06\x95\r\xBB\x05\xA2\r\xB0\r\x1A\0\xC0\r\xC0\r\xCA\r\xDA\r\xEA\r\xFA\r\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06C\x06\x10\x06\x10\x06\x10\x06\x10\x06\n\x0E\n\x0E\n\x0E\n\x0E\n\x0E\x1A\x0E\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06(\x0E\x10\x066\x0E\x10\x06o\x08\x10\x06o\x08\x10\x06\x10\x06\x10\x06B\x0EP\x0E^\x0E\x10\x06\x10\x06\x94\x05\x10\x06\x10\x06\x10\x06}\x08\x10\x06\x10\x06\x10\x06l\x08\x10\x06\x06\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06n\x0E|\x0E\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x88\x0E\x10\x06\x10\x06\x10\x06\x94\x0E\xA4\x0E\xB1\x0E\x10\x06\x10\x06\x8C\x05\xC1\x0E\xD0\x0E\x10\x06\x10\x06\x10\x06\xF1\x06\x10\x06\x10\x06\xDF\x0E\xED\x0E\x10\x06\xF2\x0E]\x07\xF3\x06\x10\x06\x02\x0F\x10\x06\x10\x06\x10\x06\x10\x0F\x1F\x0F\x10\x06\x10\x06\xDE\x06/\x0F\x10\x06\x10\x06\x10\x06\x97\x05?\x0FO\x0FO\x0FT\x0F\x10\x06d\x0Ft\x0F\x82\x0F\x8B\x02\x8B\x02\x92\x0F\x9E\x0F\x9E\x0F\x9E\x0F\xAC\x0F\xB7\x0F\xC5\x0F\xD4\x0F\xE0\x0F\x9E\x0F\xF0\x0F\xFF\x0F\0\x10\n\x10\xFB\0\xFB\0\x1A\x10\xFB\0\xFB\0\xFB\0*\x10\xFB\0\xFB\x004\x10\xFB\0\xFB\0D\x10\xFB\0\xFB\0\xFB\0T\x10d\x10T\x10T\x10d\x10t\x10T\x10\x84\x10\x94\x10\xA4\x10\xB4\x10\xC4\x10\xD3\x10\xE3\x10\xF3\x10\x03\x11\x94\x05i\x08\x12\x11\x10\x06\x10\x06\x10\x06Y\r!\x11\x10\x060\x11\x10\x06\x10\x06\x10\x06@\x11O\x11\xB4\x06_\x11o\x11}\x11\x8D\x11\x9D\x11\x10\x06\xAD\x11\xBD\x11\xCD\x11\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xD7\x11\xDD\x11\xED\x11\xF3\x11\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xE8\x04\xE8\x04\xE8\x04\t\x05\t\x05\t\x05\x03\x12\x13\x12\xFB\0\xFB\0\xFB\0\xFB\0\xFB\0\xFB\0#\x122\x12B\x12B\x12L\x12\x10\x06\x10\x06\x10\x06\x18\0\0\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\0\x10\0\x10\x10\x06\x10\x06\x18\0\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06)\0\x10\x06Z\x12j\x12\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06v\x12\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x85\x12\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06)\0\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x97\x05\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x1B\0\x10\x06\x10\x06\x10\x06\x95\x12\xFB\0[\x04\xA5\x12\xFB\0\xB5\x12\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xB3\x06\xAE\x02\xAE\x02o\x04\xC5\x12\xFB\0\xFB\0\xFB\0\xD5\x12\xE3\x12\xF3\x12\xF9\x12\t\x13\x15\x13%\x13\x10\x063\x13A\x13\x10\x06M\x13\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06Z\x13\x10\x06\0\x10j\x13\x10\x06\x10\x06s\x13\x10\x06\xE3\x06\x83\x13\x10\x06\x10\x06\xF2\x06\x10\x06\x10\x06\x90\x13\xA0\x13\x10\x06l\x08\x10\x06\x10\x06\x96\x05\xAE\x13\xBB\x13\x10\x06\x10\x06.\0\x10\x06\x10\x06\x10\x06\xCB\x13\xDB\x13\x1A\0\xD4\x08\xE8\x13\x10\x06\x10\x06\x10\x06\x8B\x02\x8B\x02\xF8\x13\x08\x14\x18\x14(\x148\x14H\x14X\x14\x10\x06\x10\x06h\x14\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06x\x14\x85\x14\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x94\x14\xF2\x06\x10\x06\x10\x06\x10\x06\xAE\x02}\x08\xA4\x14\x10\x06\x10\x06\xB4\x14\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x18\0 \0\x1D\0\xC3\x14\xC8\x14\xD8\x14\xDD\x14\x10\x06\xBB\x05\x10\x06\xDC\x06\x10\x06\x10\x06\x10\x06\x10\x06}\x08\xE8\x14\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x02\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06f\x05\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xF4\x14\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x04\x15\x04\x15\x0C\x15\x14\x15\x14\x15\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x04\x15\x04\x15$\x15\x14\x15,\x15\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06<\x15<\x15I\x15W\x15e\x15\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06u\x15\x9E\x0F\x9E\x0Fz\x15\x10\x06\x10\x06\x10\x06\x10\x06\x89\x15\x10\x06\x10\x06\x99\x15\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xA9\x15\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xB9\x15\xB9\x15\xB9\x15\xC6\x15\xD6\x15\xD6\x15\xD6\x15\xE3\x15\x10\x06\x10\x06\xEF\x15\x10\x06\x19\0\xFF\x15\t\x16\xE1\0u\0\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x19\x16\x10\x06\x10\x06\x10\x06\x10\x06&\x16\x10\x06\x10\x06\x10\x06\x10\x066\x16f\x05\x10\x06\x10\x06F\x16\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xBA\x05\x10\x06\x10\x06\xE2\x06V\x16\x10\x06\x10\x06f\x16\xF3\x06\x10\x06\x10\x06v\x16\x81\x16\x10\x06\x10\x06\x10\x06^\x07\x10\x06\x8F\x16\x9C\x16\x10\x06\x10\x06\x10\x06\x0C\x06\xF3\x06\x10\x06\x10\x06\xA6\x16\xB6\x16\x10\x06\x10\x06\x10\x06\x18\0\xC1\x16\xBA\x05\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x18\0\xD0\x16\x10\x06\xF3\x06\x10\x06\x10\x06\x82\x0B\xE0\x16\x10\x06\xEE\x16\\\x07\x10\x06\x10\x06\x10\x06\x94\x05\xFE\x16\xB9\x05p\x08\x10\x06\x10\x06\x10\x06\xE2\x06\x0E\x17\xEE\x08\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x1B\x17*\x17\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x068\x17f\x05\xD4\x08\x10\x06\x10\x06\x10\x06H\x17\xBB\x05\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06X\x17h\x17\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06p\x17\x80\x17\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x18\0\x90\x17\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xFF\x15\xFF\x15\xE1\0\xE1\0\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x9B\x17\x0C\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xAA\x17f\x05\x10\x06\xB9\x17\x10\x06\x10\x06\xC6\x17\x08\x06\xD5\x17\x10\x06\x10\x06\x95\x05\xE5\x17\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xF5\x17\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x94\x14\x05\x18\x14\x18\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06#\x182\x18\x10\x06\x10\x06\x10\x06\x10\x06B\x18\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06n\x08\xF3\x06\x10\x06\x10\x06L\x18m\x17\x1D\0\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xAE\x02V\x18\x9F\x05\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xDC\x06]\x18\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06l\x18\x10\x06\x10\x06\x10\x06|\x18\xF1\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xF2\x06\x10\x06\xD5\x08\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xFF\x15\xFF\x15\xE1\0\xE1\0\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x18\0\x10\x06\x10\x06\x10\x06\x18\0\xAE\x02\x10\x06\x10\x06\x10\x06\x10\x06\x8C\x18\x9C\x18\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xAC\x18\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xBB\x18\xF1\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xAE\x02\xAE\x02u\r\xAE\x02\xEE\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xCA\x18\xD7\x18\xE4\x18\x10\x06\xE9\x15\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xF2\x18\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x02\x19\x08\x19\x16\x19\"\x19\x04\x192\x19\x1E\x19\x02\x19B\x19N\x19^\x19l\x19|\x19\x02\x19\x08\x19\x16\x19\x88\x19\x95\x19\x12\x19\x84\x19\xA5\x19\xB4\x19\x1A\x19\x02\x19\xC4\x19\x8B\x02\x02\x19\x08\x19\x16\x19\"\x19\x04\x19\x12\x19\x1E\x19\x02\x19B\x19\x1A\x19\x02\x19\xC4\x19\x8B\x02\x02\x19\x08\x19\x16\x19\xD4\x19\x02\x19\xE3\x19\xE8\x19\xF6\x19\xFB\x19\x8B\x02\x07\x1A\x02\x19\xDF\x19\x17\x1A \x19'\x1A\x8B\x027\x1A\x02\x19-\x1A\x8B\x02=\x1A\x10\x06\x10\x06\x10\x06\xAE\x02\xAE\x02\xAE\x02M\x1A\xAE\x02\xAE\x02v\r)\0*\0\x94\x05^\r\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06]\x1Ah\x1Aw\x1A\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x87\x1A\x8F\x1A\x9D\x1A\x9E\x0F\xAD\x1A\x9E\x0F\xBB\x1A\x10\x06A\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xCB\x1A\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xEE\x08\x10\x06\x10\x06\x10\x06D\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xD9\x1A\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x8D\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xE9\x1A\x10\x06\x10\x06\xF9\x1A\xF9\x1A\x07\x1B\t\x1B\x15\x1B\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x02\x19%\x1B\x02\x19%\x1B\x02\x19%\x1B\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x94\x05\xBA\x05\x10\x06\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\x10\x06\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\xAE\x02\x10\x06y\0\x99\0\xB9\0\xD9\0\xF9\0\x19\x019\x01Y\x01y\x01\x89\x01\xA9\x01\xB8\x01\xD8\x01\xF7\x01\x17\x027\x02W\x02\xA9\x01p\x02\xA9\x01\xA9\x01\xA9\x01\x90\x02\xB0\x02\xD0\x02\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xEF\x02\xA9\x01\0\x03 \x03@\x03_\x03\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01~\x03\xA9\x01\x9E\x03\xBE\x03\xDE\x03\xFE\x03\x1A\x04\xA9\x01:\x04R\x04k\x04\x8B\x04\xA9\x04\xC8\x04\xE6\x04\x04\x05$\x05A\x05[\x05\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01x\x05\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\x87\x05\xA9\x01\xA9\x01\xA9\x01\xA9\x01\x9A\x05\xAF\x05\xCB\x05\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xEB\x05\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\x0B\x06\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\x1B\x060\x06L\x06l\x06\x8C\x06\xA9\x01\xAC\x06\xA9\x01\xBC\x06\xDC\x06\xF2\x06\x04\x07\xA9\x01#\x07\xA9\x01\xA9\x01\xA9\x018\x07Q\x07\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01\xA9\x01") }, unsafe { zerovec::ZeroVec::from_bytes_unchecked(b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\n\0\x1A\0*\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10:\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\0\0\0\0\0\0\x04\0\0\0\x04\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0I\x001\xF0Y\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0i\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\x01\0\0\0\0\0\x04\0\0\0\x04\0\0\0\0\0\0\0\0\0\x04\0y\0\0\0\x04\0\x04\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x8A\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x1A\0\x1A\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\0\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x99\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\xA9\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\0\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x91<\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xBA\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xBA\0\xB1\xFF\xCA\0\xD9\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xE9\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\xC3\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xF9\0\x91a\x12i\x92\0\x91\xFF\x92\0\x91\xFF\x12g\x92\0\x91\xFF\x92f\x92f\x92\0\x91\xFF\x01\0\x92'\x12e\x92e\x92\0\x91\xFF\x92f\x92g\x910\x92i\x92h\x92\0\x91\xFF\x91Q\t\x01\x92i\x92j\x11A\x12k\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x12m\x92\0\x91\xFF\x12m\x01\0\x01\0\x92\0\x91\xFF\x12m\x92\0\x91\xFF\x92l\x92l\x92\0\x91\xFF\x92\0\x91\xFF\x92m\x92\0\x91\xFF\x01\0\0\0\x92\0\x91\xFF\x01\0\x11\x1C\0\0\0\0\0\0\0\0\x1A\x01+\x019\x01J\x01[\x01i\x01z\x01\x8B\x01\x99\x01\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x91\xD8\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xA9\x01\xBA\x01\xCB\x01\xD9\x01\x92\0\x91\xFF\x92\xCF\x12\xE4\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x12\xBF\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\xEA\x01\x92\0\x91\xFF\x92\xAE\xFA\x01\t\x02\x92\0\x91\xFF\x92\x9E\x92\"\x92#\x92\0\x91\xFF\x92\0\xB1\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x19\x02)\x029\x02\x11\x97\x11\x99\x01\0\x91\x99\x91\x99\x01\0\x11\x9B\x01\0\x91\x9AI\x02\x01\0\x01\0\x01\0\x91\x99Y\x02\x01\0\x91\x98i\x02y\x02\x89\x02\x01\0\xB1\x97\x91\x96\x89\x02\x99\x02\xA9\x02\x01\0\x01\0\x91\x96\x01\0\xB9\x02\x91\x95\x01\0\x01\0\x11\x95\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\xC9\x02\x01\0\x01\0\x11\x93\x01\0\xD9\x02\x11\x93\x01\0\x01\0\x01\0\xE9\x02\x11\x93\x91\xDD\x91\x93\x91\x93\x91\xDC\x01\0\x01\0\x01\0\x01\0\x01\0\x91\x92\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\xF9\x02\t\x03\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x05\0\x05\0%\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x04\0\x04\0\x04\0\x14\0\x04\0\x14\0\x04\0\x05\0\x05\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x05\0\x05\0\x05\0\x05\0\x05\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0T\0T\0D\0D\0D\0D\0D\0\x1C\x03T\0D\0T\0D\0T\0D\0D\0D\0D\0D\0D\0T\0D\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0t\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0D\0D\0D\0T\0D\0D\0-\x03D\0d\0d\0d\0D\0D\0D\0d\0d\0\x04\0D\0D\0D\0d\0d\0d\0d\0D\0d\0d\0d\0D\0d\0d\0d\0d\0d\0d\0d\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0\x92\0\x91\xFF\x92\0\x91\xFF\x04\0\x04\0\x92\0\x91\xFF\0\0\0\0\x05\0\x11A\x11A\x11A\0\0\x12:\0\0\0\0\0\0\0\0\x04\0\x04\0\x12\x13\x04\0\x92\x12\x92\x12\x92\x12\0\0\x12 \0\0\x92\x1F\x92\x1F9\x03\x12\x10J\x03\x12\x10\x12\x10Z\x03\x12\x10\x12\x10j\x03z\x03\x8A\x03\x12\x10\x9A\x03\x12\x10\x12\x10\x12\x10\xAA\x03\xBA\x03\0\0\xCA\x03\x12\x10\x12\x10\xDA\x03\x12\x10\x12\x10\xEA\x03\x12\x10\x12\x10\x11\xED\x91\xED\x91\xED\x91\xED\xF9\x03\x11\xF0\t\x04\x11\xF0\x11\xF0\x19\x04\x11\xF0\x11\xF0)\x049\x04I\x04\x11\xF0Y\x04\x11\xF0\x11\xF0\x11\xF0i\x04y\x04\x89\x04\x99\x04\x11\xF0\x11\xF0\xA9\x04\x11\xF0\x11\xF0\xB9\x04\x11\xF0\x11\xF0\x11\xE0\x91\xE0\x91\xE0\x12\x04\xC9\x04\xD9\x04\x02\0\x02\0\x02\0\xE9\x04\xF9\x04\x11\xFC\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\t\x05\x19\x05\x91\x031\xC6*\x059\x05\0\0\x92\0\x91\xFF\x92\xFC\x92\0\x91\xFF\x01\0\x12\xBF\x12\xBF\x12\xBF\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12(\x12\x10\x12\x10J\x05\x12\x10Z\x05\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10j\x05\x12\x10\x12\x10z\x05\x8A\x05\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x9A\x05\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x11\xF0\x11\xF0\xA9\x05\x11\xF0\xB9\x05\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\xC9\x05\x11\xF0\xD9\x05\xE9\x05\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\xF9\x05\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xD8\x11\xD8\x11\xD8\x11\xD8\x11\xD8\x11\xD81\xD8\x11\xD81\xD8\x11\xD8\x11\xD8\x11\xD8\x11\xD8\x11\xD8\x11\xD8\x11\xD8\x92\0\x91\xFF\n\x06\x19\x06\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\0\0D\0D\0D\0D\0D\0\x04\0\x04\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\x07\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x91\xF8\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\0\0\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\x12\x18\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0\x01\0\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8\x11\xE8)\x06\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0D\0D\0D\0D\0d\0D\0D\0D\0d\0d\0D\0D\0D\0D\0D\0D\0d\0d\0d\0d\0d\0d\0D\0D\0d\0D\0D\0d\0d\0D\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0d\0\0\0d\0d\0\0\0D\0d\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0D\0d\0d\0d\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0d\0d\0d\0d\0d\0d\0D\0D\0d\0d\0D\0D\0D\0D\0D\0d\0D\0D\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0\x04\0\0\0D\0D\0D\0D\0d\0D\0\x04\0\x04\0D\0D\0\0\0d\0D\0D\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0d\0D\0D\0d\0D\0D\0d\0d\0d\0D\0d\0d\0D\0d\0D\0D\0d\0D\0d\0D\0d\0D\0d\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0d\0D\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0\x04\0D\0D\0D\0D\0D\0D\0D\0D\0D\0\x04\0D\0D\0D\0\x04\0D\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0D\0D\0d\0d\0d\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0D\0D\0D\0D\0D\0d\0d\0d\0d\0d\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0\x04\0d\0D\0D\0d\0D\0D\0d\0D\0D\0D\0d\0d\0d\0d\0d\0d\0D\0D\0D\0d\0D\0D\0d\0d\0D\0D\0D\0D\0D\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0d\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0D\0d\0D\0D\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0d\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0d\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0d\0d\0d\0d\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0d\0d\0d\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0d\0d\0d\0d\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0d\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0\x04\0d\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0d\0d\0d\0\x04\0\0\0d\0\x04\0D\0D\0d\0\0\0D\0D\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0\0\0d\0d\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06:\x06\0\0:\x06\0\0\0\0\0\0\0\0\0\0:\x06\0\0\0\0I\x06Y\x06i\x06y\x06\x89\x06\x99\x06\xA9\x06\xB9\x06\xC9\x06\xD9\x06\xE9\x06\xF9\x06\t\x07\x19\x07)\x079\x07I\x07Y\x07i\x07y\x07\x89\x07\x99\x07\xA9\x07\xB9\x07\xC9\x07\xD9\x07\xE9\x07\xF9\x07\t\x08\x19\x08)\x089\x08I\x08Y\x08i\x08y\x08\x89\x08\x99\x08\xA9\x08\xB9\x08\xC9\x08\xD9\x08\xE9\x08\0\0\x05\0\xF9\x08\t\t\x19\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t*\t:\t:\t:\t:\t:\t:\t\0\0\0\0I\tY\ti\ty\t\x89\t\x99\t\0\0\0\0\x04\0\x04\0d\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0\x04\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0D\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0d\0D\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0d\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0d\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\x04\0D\0D\0D\0D\0D\0D\0D\0D\0\0\0\0\0d\0D\0D\0D\0D\0D\0d\0d\0d\0d\0d\0d\0D\0D\0d\0\x04\0d\0D\0D\0d\0d\0D\0D\0D\0D\0D\0d\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0d\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\0\0\0\0\0\0\x04\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0d\0D\0D\0D\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0`\0d\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\0\0\x04\0\x04\0`\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xA9\t\xB9\t\xC9\t\xD9\t\xE9\t\xF9\t\t\n\x19\n)\n\x92\0\x91\xFF\0\0\0\0\0\0\0\0\0\0:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n:\n\0\0\0\0:\n:\n:\nD\0D\0D\0\0\0d\0d\0d\0d\0d\0d\0D\0D\0d\0d\0d\0d\0D\0\0\0d\0d\0d\0d\0d\0d\0d\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0D\0\0\0\0\0\0\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0%\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x05\0I\n\x01\0\x01\0\x01\0Y\n\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0i\n\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0!\0\x01\0\x01\0\x01\0\x01\0\x05\0\x05\0\x05\0\x05\0\x05\0%\0\x05\0\x05\0\x05\0%\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0D\0D\0d\0D\0D\0D\0D\0D\0D\0D\0d\0D\0D\0d\0d\0d\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0d\0d\0d\0d\0d\0D\0d\0d\0D\0d\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\xB1\xFF\x92\0\x91\xFFz\n\x89\n\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x99\n\xA9\n\xB9\n\xC9\n\xD9\n\xE9\n\x01\0\x01\0\xFA\n\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\xB1\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x11\x04\x11\x04\x11\x04\x11\x04\x11\x04\x11\x04\x11\x04\x11\x04\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x11\x04\x11\x04\x11\x04\x11\x04\x11\x04\x11\x04\0\0\0\0\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x12\xFC\x12\xFC\0\0\0\0\t\x0B\x11\x04\x19\x0B\x11\x04)\x0B\x11\x049\x0B\x11\x04\0\0\x12\xFC\0\0\x12\xFC\0\0\x12\xFC\0\0\x12\xFC\x11%\x11%\x11+\x11+\x11+\x11+\x112\x112\x11@\x11@\x118\x118\x11?\x11?\0\0\0\0I\x0BY\x0Bi\x0By\x0B\x89\x0B\x99\x0B\xA9\x0B\xB9\x0B\xCB\x0B\xDB\x0B\xEB\x0B\xFB\x0B\x0B\x0C\x1B\x0C+\x0C;\x0CI\x0CY\x0Ci\x0Cy\x0C\x89\x0C\x99\x0C\xA9\x0C\xB9\x0C\xCB\x0C\xDB\x0C\xEB\x0C\xFB\x0C\x0B\r\x1B\r+\r;\rI\rY\ri\ry\r\x89\r\x99\r\xA9\r\xB9\r\xCB\r\xDB\r\xEB\r\xFB\r\x0B\x0E\x1B\x0E+\x0E;\x0E\x11\x04\x11\x04I\x0EY\x0Ei\x0E\0\0y\x0E\x89\x0E\x12\xFC\x12\xFC\x12\xDB\x12\xDB\x9B\x0E\x04\0\xA9\x0E\x04\0\x04\0\xB9\x0E\xC9\x0E\xD9\x0E\0\0\xE9\x0E\xF9\x0E\x12\xD5\x12\xD5\x12\xD5\x12\xD5\x0B\x0F\x04\0\x04\0\x04\0\x11\x04\x11\x04\x19\x0F)\x0F\0\0\0\09\x0FI\x0F\x12\xFC\x12\xFC\x12\xCE\x12\xCE\0\0\x04\0\x04\0\x04\0\x11\x04\x11\x04Y\x0Fi\x0Fy\x0F\x91\x03\x89\x0F\x99\x0F\x12\xFC\x12\xFC\x12\xC8\x12\xC8\x92\xFC\x04\0\x04\0\x04\0\0\0\0\0\xA9\x0F\xB9\x0F\xC9\x0F\0\0\xD9\x0F\xE9\x0F\x12\xC0\x12\xC0\x12\xC1\x12\xC1\xFB\x0F\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\0\0\0\0\0\0D\0D\0d\0d\0D\0D\0D\0D\0d\0d\0d\0D\0D\0\x04\0\x04\0\x04\0D\0\x04\0\x04\0\x04\0d\0d\0D\0d\0D\0d\0d\0d\0d\0d\0d\0\0\0\0\0\x02\0\0\0\0\0\0\0\0\0\x02\0\0\0\0\0\x01\0\x02\0\x02\0\x02\0\x01\0\x01\0\x02\0\x02\0\x02\0\x01\0\0\0\x02\0\0\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\0\0\0\0\0\0\x02\0\0\0\n\x10\0\0\x02\0\0\0\x1A\x10*\x10\x02\0\x02\0\0\0\x01\0\x02\0\x02\0\x12\x0E\x02\0\x01\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\x01\0\x01\0\x02\0\x02\0\0\0\0\0\0\0\0\0\0\0\x02\0\x01\0\x01\0!\0!\0\0\0\0\0\0\0\0\0\x11\xF2\0\0\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x12\x08\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\x11\xF8\0\0\0\0\0\0\x92\0\x91\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x12\r\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\x11\xF3\0\0\0\0\0\0\0\0\0\0\0\0\x92\0\x91\xFF:\x10J\x10Z\x10i\x10y\x10\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x8A\x10\x9A\x10\xAA\x10\xBA\x10\x01\0\x92\0\x91\xFF\x01\0\x92\0\x91\xFF\x01\0\x01\0\x01\0\x01\0\x01\0%\0\x05\0\xCA\x10\xCA\x10\x92\0\x91\xFF\x92\0\x91\xFF\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\0\x91\xFF\x92\0\x91\xFFD\0D\0\x92\0\x91\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\xD9\x10\0\0\xD9\x10\0\0\0\0\0\0\0\0\0\0\xD9\x10\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0d\0d\0`\0`\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xEA\x10\xF9\x10\x92\0\x91\xFF\x92\0\x91\xFF\x04\0\x04\0\x04\0\0\0D\0D\0D\0D\0D\0D\0D\0D\0D\0D\0\0\0\x04\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x05\0\x05\0D\0D\0\x01\0\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x05\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\n\x11\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x04\0\x04\0\x04\0\x92\0\x91\xFF\x1A\x11\x01\0\0\0\x92\0\x91\xFF\x92\0\x91\xFF\x11\x18\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF*\x11:\x11J\x11Z\x11*\x11\x01\0j\x11z\x11\x8A\x11\x9A\x11\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\x12\xE8\xAA\x11\xBA\x11\x92\0\x91\xFF\x92\0\x91\xFF\xCA\x11\x92\0\x91\xFF\0\0\0\0\x92\0\x91\xFF\0\0\x01\0\0\0\x01\0\x92\0\x91\xFF\x92\0\x91\xFF\x92\0\x91\xFF\xDA\x11\0\0\0\0\0\0\x05\0\x05\0\x05\0\x92\0\x91\xFF\0\0\x05\0\x05\0\x01\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0d\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0d\0d\0\0\0\0\0\x04\0\x04\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0D\0\0\0D\0D\0d\0\0\0\0\0D\0D\0\0\0\0\0\0\0\0\0\0\0D\0D\0\0\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\x01\0\x01\0\xE9\x11\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x04\0\x05\0\x05\0\x05\0\x05\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x05\0\x04\0\x04\0\0\0\0\0\0\0\0\0\xF9\x11\t\x12\x19\x12)\x129\x12I\x12Y\x12i\x12y\x12\x89\x12\x99\x12\xA9\x12\xB9\x12\xC9\x12\xD9\x12\xE9\x12\xF9\x12\t\x13\x19\x13)\x139\x13I\x13Y\x13i\x13y\x13\x89\x13\x99\x13\xA9\x13\xB9\x13\xC9\x13\xD9\x13\xE9\x13\xF9\x13\t\x14\x19\x14)\x149\x14I\x14Y\x14i\x14y\x14\x89\x14\x99\x14\xA9\x14\xB9\x14\xC9\x14\xD9\x14\xE9\x14\xF9\x14\t\x15\x19\x15)\x159\x15I\x15Y\x15i\x15y\x15\x89\x15\x99\x15\xA9\x15\xB9\x15\xC9\x15\xD9\x15\xE9\x15\xF9\x15\t\x16\x19\x16)\x169\x16I\x16Y\x16i\x16y\x16\x89\x16\x99\x16\xA9\x16\xB9\x16\xC9\x16\xD9\x16\xE9\x16\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\xF9\x16\t\x17\x19\x17)\x179\x17I\x17Y\x17\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x17y\x17\x89\x17\x99\x17\xA9\x17\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0D\0D\0D\0D\0D\0D\0D\0d\0d\0d\0d\0d\0d\0d\0D\0D\0\0\0\0\0\x04\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\0\0\0\0\0\0\x04\0\0\0\x04\0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\x11\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x12\x14\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x12\x14\x12\x14\x12\x14\x12\x14\0\0\0\0\0\0\0\0\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\x11\xEC\0\0\0\0\0\0\0\0\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\x92\x13\0\0\x92\x13\x92\x13\x92\x13\x92\x13\0\0\x92\x13\x92\x13\0\0\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\0\0\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\0\0\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\x91\xEC\0\0\x91\xEC\x91\xEC\0\0\0\0\0\0\x05\0\x04\0\x04\0\x05\0\x05\0\x05\0\0\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0\x04\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0d\0d\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\0\0\0\0D\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \x12 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\x11\xE0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\x12\x10\0\0\0\0\0\0D\0D\0D\0D\0D\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0d\0d\0D\0D\0D\0d\0D\0d\0d\0d\0\0\0\0\0D\0d\0D\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0d\0d\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0\x04\0\x04\0\0\0\0\0\x04\0`\0d\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0d\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0`\0\0\0\0\0d\0\x04\0\x04\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\0\0\0\0\0\0\0\0\x04\0\0\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0d\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0`\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0d\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0`\0d\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0d\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\0\0\x04\0\x04\0\0\0\x04\0\x04\0d\0\x04\0d\0d\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\0\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\x04\0\x04\0d\0d\0d\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0\0\0\0\0\0\0\0\0\0\0`\0`\0d\0d\0d\0\0\0\0\0\0\0`\0`\0`\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0d\0d\0d\0d\0d\0\0\0\0\0D\0D\0D\0D\0D\0d\0d\0\0\0\0\0\0\0\0\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0!\0!\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0!\0!\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0!\0!\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\0\0\x02\0\x02\0\0\0\0\0\x02\0\0\0\0\0\x02\0\x02\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x01\0\x01\0\x01\0\x01\0\0\0\x01\0\0\0\x01\0!\0!\0\x01\0\x01\0\x01\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\0\0\x02\0\x02\0\x02\0\x02\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x02\0\0\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0!\0!\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0!\0!\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x01\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\x04\0\x04\0\x04\0\x04\0\x04\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0!\0\x01\0\x01\0\x01\0\x01\0\0\0\0\0\0\0\0\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\0\0\0\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0\0\0D\0D\0D\0D\0D\0D\0D\0D\0D\0\0\0\0\0D\0D\0D\0D\0D\0\0\0D\0D\0\0\0D\0D\0D\0D\0D\0\0\0\0\0\0\0\0\0\0\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0%\0%\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0%\0\x05\0\x05\0\x05\0\x05\0\x05\0\0\0\0\0D\0D\0D\0D\0D\0D\0D\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0d\0d\0d\0D\0d\0d\0d\0d\0d\0d\0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x12\x11\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEF\x11\xEFD\0D\0D\0D\0D\0D\0d\0\x04\0\0\0\0\0\0\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0") }, icu::casemap::provider::data::CaseMapData { ignoreable: false, kind: icu::casemap::provider::data::CaseMapDataKind::Uncased(icu::casemap::provider::data::NonExceptionData { sensitive: false, dot_type: icu::casemap::provider::data::DotType::NoDot }) }), exceptions: icu::casemap::provider::exceptions::CaseMapExceptions { exceptions: unsafe { zerovec::vecs::VarZeroVec16::from_bytes_unchecked(b"{\x01\x07\0\n\0\x10\0\x15\0\x1C\0\"\0'\0-\x004\0C\0J\0M\0T\0Z\0h\0l\0q\0w\0\x7F\0\x85\0\x8B\0\x93\0\x99\0\x9F\0\xA7\0\xAD\0\xBB\0\xC1\0\xC9\0\xCF\0\xD4\0\xD9\0\xDE\0\xE3\0\xE8\0\xED\0\xF2\0\xF7\0\xFC\0\x01\x01\x06\x01\x0B\x01\x10\x01\x15\x01\x1A\x01\x1F\x01$\x01)\x01.\x010\x019\x01T\x01Z\x01`\x01h\x01q\x01w\x01}\x01\x83\x01\x89\x01\x8E\x01\x94\x01\x9B\x01\xB6\x01\xBC\x01\xC2\x01\xCA\x01\xD3\x01\xD9\x01\xDF\x01\xE5\x01\xEB\x01\xF1\x01\xF7\x01\xFD\x01\x04\x02\n\x02\x12\x02\x18\x02\x1E\x02$\x02*\x022\x028\x02?\x02F\x02M\x02T\x02^\x02e\x02l\x02s\x02z\x02\x81\x02\x8B\x02\x92\x02\x99\x02\xA0\x02\xA9\x02\xAE\x02\xB6\x02\xBE\x02\xC6\x02\xCE\x02\xD6\x02\xDE\x02\xE6\x02\xEE\x02\xF6\x02\xFE\x02\x06\x03\x0E\x03\x16\x03\x1E\x03&\x03.\x036\x03>\x03F\x03N\x03V\x03^\x03f\x03n\x03v\x03~\x03\x86\x03\x8E\x03\x96\x03\x9E\x03\xA6\x03\xAE\x03\xB6\x03\xBE\x03\xC6\x03\xCE\x03\xD6\x03\xDE\x03\xE6\x03\xEE\x03\xF6\x03\xFE\x03\x06\x04\x0E\x04\x16\x04\x1E\x04#\x04&\x04.\x046\x04>\x04F\x04N\x04V\x04\\\x04b\x04h\x04n\x04w\x04\x80\x04\x86\x04\x8C\x04\x94\x04\x99\x04\x9E\x04\xA3\x04\xA8\x04\xB0\x04\xB8\x04\xC6\x04\xD4\x04\xE2\x04\xF0\x04\xFE\x04\x06\x05\x10\x05!\x058\x05O\x05f\x05v\x05\x86\x05\x96\x05\xA6\x05\xB6\x05\xC6\x05\xD6\x05\xE6\x05\xF6\x05\x06\x06\x16\x06&\x066\x06F\x06V\x06f\x06v\x06\x86\x06\x96\x06\xA6\x06\xB6\x06\xC6\x06\xD6\x06\xE6\x06\xF6\x06\x06\x07\x16\x07&\x076\x07F\x07V\x07f\x07v\x07\x86\x07\x96\x07\xA6\x07\xB6\x07\xC6\x07\xD6\x07\xE6\x07\xF6\x07\x06\x08\x16\x08&\x086\x08F\x08V\x08f\x08z\x08\x88\x08\x99\x08\xAA\x08\xC1\x08\xCF\x08\xD7\x08\xEB\x08\xF9\x08\n\t\x1B\t2\t@\tW\tp\t\x81\t\x98\t\xAF\t\xC8\t\xD9\t\xEA\t\x01\n\x15\n#\n4\nE\n\\\nj\nq\nw\n~\n\x83\n\x88\n\x8D\n\x92\n\x97\n\x9C\n\xA1\n\xA6\n\xAB\n\xB0\n\xB5\n\xBD\n\xC5\n\xCA\n\xCF\n\xD4\n\xD9\n\xDE\n\xE3\n\xE8\n\xED\n\xF2\n\xF6\n\xFB\n\0\x0B\x05\x0B\n\x0B\x0E\x0B\x16\x0B\x1E\x0B&\x0B.\x0B6\x0B>\x0BF\x0BN\x0BV\x0B^\x0Bf\x0Bn\x0Bv\x0B~\x0B\x86\x0B\x8E\x0B\x96\x0B\x9E\x0B\xA6\x0B\xAE\x0B\xB6\x0B\xBE\x0B\xC6\x0B\xCE\x0B\xD6\x0B\xDE\x0B\xE6\x0B\xEE\x0B\xF6\x0B\xFE\x0B\x06\x0C\x0E\x0C\x16\x0C\x1E\x0C&\x0C.\x0C6\x0C>\x0CF\x0CN\x0CV\x0C^\x0Cf\x0Cn\x0Cv\x0C~\x0C\x86\x0C\x8E\x0C\x96\x0C\x9E\x0C\xA6\x0C\xAE\x0C\xB6\x0C\xBE\x0C\xC6\x0C\xCE\x0C\xD6\x0C\xDE\x0C\xE6\x0C\xEE\x0C\xF6\x0C\xFE\x0C\x06\r\x0E\r\x16\r\x1E\r&\r.\r6\r>\rF\rN\rV\r^\rf\rn\rv\r~\r\x86\r\x8E\r\x99\r\xA4\r\xAF\r\xBD\r\xCB\r\xD9\r\xE8\r\xF9\r\n\x0E\x1B\x0E,\x0E\xC8P \xC4\xB0\xC4\xB1H\x10 \x08Ak\xE2\x84\xAA\x08As\xC5\xBF\\P \xC4\xB0\xC4\xB1\x08DK\xE2\x84\xAA\x08DS\xC5\xBF\x08\x06\xCE\xBC\xCE\x9C\x08A\xC3\xA5\xE2\x84\xAB\x08\xC0\x03\xE1\xBA\x9E\0\x02\x04ssSSSs\x08D\xC3\x85\xE2\x84\xABH\x10\x01\xCEP\xC3\x87I\xC4\xB1\x08DIi\xC4\xB0\x08\x80\0\x03\x06\xCA\xBCn\xCA\xBCN\xCA\xBCN\x08\x06sS\x08\x10\xEA\x99\x81\x08\t\xC7\x86\xC7\x85\x08\r\xC7\x86\xC7\x84\xC7\x85\x08\x0C\xC7\x84\xC7\x85\x08\t\xC7\x89\xC7\x88\x08\r\xC7\x89\xC7\x87\xC7\x88\x08\x0C\xC7\x87\xC7\x88\x08\t\xC7\x8C\xC7\x8B\x08\r\xC7\x8C\xC7\x8A\xC7\x8B\x08\x0C\xC7\x8A\xC7\x8B\x08\x80\0\x03\x06j\xCC\x8CJ\xCC\x8CJ\xCC\x8C\x08\t\xC7\xB3\xC7\xB2\x08\r\xC7\xB3\xC7\xB1\xC7\xB2\x08\x0C\xC7\xB1\xC7\xB2\x08\x10\xE2\xA8\xAB\x08\x10\xE2\xA8\xA8\x08\x10\xE2\xA8\xBF\x08\x10\xE2\xA8\x9F\x08\x10\xE2\xA8\x9C\x08\x10\xE2\xA8\x9E\x08\x10\xEA\x95\x8F\x08\x10\xEA\x95\x8B\x08\x10\xEA\x95\xA7\x08\x10\xEA\x94\xA8\x08\x10\xEA\x95\x84\x08\x10\xE2\xA7\xB7\x08\x10\xEA\x95\x81\x08\x10\xE2\xA7\xBD\x08\x10\xE2\xA7\xA7\x08\x10\xEA\x95\x83\x08\x10\xEA\x94\xAA\x18\x10\xEA\x94\x95\x08\x10\xEA\x94\x92h\08F\xCE\xB9\xCE\x99\xE1\xBE\xBE\x08\xC0\x03\xE1\xBF\x93\0\x06\x0C\xCE\xB9\xCC\x88\xCC\x81\xCE\x99\xCC\x88\xCC\x81\xCE\x99\xCC\x88\xCC\x81\x08A\xCE\xB2\xCF\x90\x08A\xCE\xB5\xCF\xB5\x08A\xCE\xB8\xCF\x91\xCF\xB4\x08A\xCE\xB9\xCD\x85\xE1\xBE\xBE\x08A\xCE\xBA\xCF\xB0\x08A\xCE\xBC\xC2\xB5\x08A\xCF\x80\xCF\x96\x08A\xCF\x81\xCF\xB1HP \xCF\x82\x08A\xCF\x86\xCF\x95\x08A\xCF\x89\xE2\x84\xA6\x08\xC0\x03\xE1\xBF\xA3\0\x06\x0C\xCF\x85\xCC\x88\xCC\x81\xCE\xA5\xCC\x88\xCC\x81\xCE\xA5\xCC\x88\xCC\x81\x08D\xCE\x92\xCF\x90\x08D\xCE\x95\xCF\xB5\x08D\xCE\x98\xCF\x91\xCF\xB4\x08D\xCE\x99\xCD\x85\xE1\xBE\xBE\x08D\xCE\x9A\xCF\xB0\x08D\xCE\x9C\xC2\xB5\x08D\xCE\xA0\xCF\x96\x08D\xCE\xA1\xCF\xB1\x08\x06\xCF\x83\xCE\xA3\x08D\xCE\xA3\xCF\x82\x08D\xCE\xA6\xCF\x95\x08D\xCE\xA9\xE2\x84\xA6\x08\x06\xCE\xB2\xCE\x92\x08F\xCE\xB8\xCE\x98\xCF\xB4\x08\x06\xCF\x86\xCE\xA6\x08\x06\xCF\x80\xCE\xA0\x08\x06\xCE\xBA\xCE\x9A\x08\x06\xCF\x81\xCE\xA1\x08A\xCE\xB8\xCE\x98\xCF\x91\x08\x06\xCE\xB5\xCE\x95\x08A\xD0\xB2\xE1\xB2\x80\x08A\xD0\xB4\xE1\xB2\x81\x08A\xD0\xBE\xE1\xB2\x82\x08A\xD1\x81\xE1\xB2\x83\x08A\xD1\x82\xE1\xB2\x84\xE1\xB2\x85\x08A\xD1\x8A\xE1\xB2\x86\x08D\xD0\x92\xE1\xB2\x80\x08D\xD0\x94\xE1\xB2\x81\x08D\xD0\x9E\xE1\xB2\x82\x08D\xD0\xA1\xE1\xB2\x83\x08D\xD0\xA2\xE1\xB2\x84\xE1\xB2\x85\x08D\xD0\xAA\xE1\xB2\x86\x08A\xD1\xA3\xE1\xB2\x87\x08D\xD1\xA2\xE1\xB2\x87H\x80\0\x04\x04\xD5\xA5\xD6\x82\x08\x10\xE1\xB1\xA0\x08\x0C\xE1\xB2\x90\xE1\x83\x90\x08\x0C\xE1\xB2\x91\xE1\x83\x91\x08\x0C\xE1\xB2\x92\xE1\x83\x92\x08\x0C\xE1\xB2\x93\xE1\x83\x93\x08\x0C\xE1\xB2\x94\xE1\x83\x94\x08\x0C\xE1\xB2\x95\xE1\x83\x95\x08\x0C\xE1\xB2\x96\xE1\x83\x96\x08\x0C\xE1\xB2\x97\xE1\x83\x97\x08\x0C\xE1\xB2\x98\xE1\x83\x98\x08\x0C\xE1\xB2\x99\xE1\x83\x99\x08\x0C\xE1\xB2\x9A\xE1\x83\x9A\x08\x0C\xE1\xB2\x9B\xE1\x83\x9B\x08\x0C\xE1\xB2\x9C\xE1\x83\x9C\x08\x0C\xE1\xB2\x9D\xE1\x83\x9D\x08\x0C\xE1\xB2\x9E\xE1\x83\x9E\x08\x0C\xE1\xB2\x9F\xE1\x83\x9F\x08\x0C\xE1\xB2\xA0\xE1\x83\xA0\x08\x0C\xE1\xB2\xA1\xE1\x83\xA1\x08\x0C\xE1\xB2\xA2\xE1\x83\xA2\x08\x0C\xE1\xB2\xA3\xE1\x83\xA3\x08\x0C\xE1\xB2\xA4\xE1\x83\xA4\x08\x0C\xE1\xB2\xA5\xE1\x83\xA5\x08\x0C\xE1\xB2\xA6\xE1\x83\xA6\x08\x0C\xE1\xB2\xA7\xE1\x83\xA7\x08\x0C\xE1\xB2\xA8\xE1\x83\xA8\x08\x0C\xE1\xB2\xA9\xE1\x83\xA9\x08\x0C\xE1\xB2\xAA\xE1\x83\xAA\x08\x0C\xE1\xB2\xAB\xE1\x83\xAB\x08\x0C\xE1\xB2\xAC\xE1\x83\xAC\x08\x0C\xE1\xB2\xAD\xE1\x83\xAD\x08\x0C\xE1\xB2\xAE\xE1\x83\xAE\x08\x0C\xE1\xB2\xAF\xE1\x83\xAF\x08\x0C\xE1\xB2\xB0\xE1\x83\xB0\x08\x0C\xE1\xB2\xB1\xE1\x83\xB1\x08\x0C\xE1\xB2\xB2\xE1\x83\xB2\x08\x0C\xE1\xB2\xB3\xE1\x83\xB3\x08\x0C\xE1\xB2\xB4\xE1\x83\xB4\x08\x0C\xE1\xB2\xB5\xE1\x83\xB5\x08\x0C\xE1\xB2\xB6\xE1\x83\xB6\x08\x0C\xE1\xB2\xB7\xE1\x83\xB7\x08\x0C\xE1\xB2\xB8\xE1\x83\xB8\x08\x0C\xE1\xB2\xB9\xE1\x83\xB9\x08\x0C\xE1\xB2\xBA\xE1\x83\xBA\x08\x0C\xE1\xB2\xBD\xE1\x83\xBD\x08\x0C\xE1\xB2\xBE\xE1\x83\xBE\x08\x0C\xE1\xB2\xBF\xE1\x83\xBF\n\x10\xE9\x9F\x90\n\x10\x08\x08\x06\xE1\x8F\xB0\xE1\x8F\xB0\x08\x06\xE1\x8F\xB1\xE1\x8F\xB1\x08\x06\xE1\x8F\xB2\xE1\x8F\xB2\x08\x06\xE1\x8F\xB3\xE1\x8F\xB3\x08\x06\xE1\x8F\xB4\xE1\x8F\xB4\x08\x06\xE1\x8F\xB5\xE1\x8F\xB5\x08\x06\xD0\xB2\xD0\x92\x08\x06\xD0\xB4\xD0\x94\x08\x06\xD0\xBE\xD0\x9E\x08\x06\xD1\x81\xD0\xA1\x08F\xD1\x82\xD0\xA2\xE1\xB2\x85\x08F\xD1\x82\xD0\xA2\xE1\xB2\x84\x08\x06\xD1\x8A\xD0\xAA\x08\x06\xD1\xA3\xD1\xA2\x08\x06\xEA\x99\x8B\xEA\x99\x8A\x0C\x10\xE0\xAF\x80\x08\x10\xE8\xA8\x84\x08\x10\xE0\xBB\xA6\x08\x10\xE8\xA8\xB8\x08A\xE1\xB9\xA1\xE1\xBA\x9B\x08D\xE1\xB9\xA0\xE1\xBA\x9B\x08\x80\0\x03\x06h\xCC\xB1H\xCC\xB1H\xCC\xB1\x08\x80\0\x03\x06t\xCC\x88T\xCC\x88T\xCC\x88\x08\x80\0\x03\x06w\xCC\x8AW\xCC\x8AW\xCC\x8A\x08\x80\0\x03\x06y\xCC\x8AY\xCC\x8AY\xCC\x8A\x08\x80\0\x03\x06a\xCA\xBEA\xCA\xBEA\xCA\xBE\x08\x06\xE1\xB9\xA1\xE1\xB9\xA0\x0C\x90\xE1\xB6\xBF\0\x02\x02ss\x08\x80\0\x04\x08\xCF\x85\xCC\x93\xCE\xA5\xCC\x93\xCE\xA5\xCC\x93\x08\x80\0\x06\x0C\xCF\x85\xCC\x93\xCC\x80\xCE\xA5\xCC\x93\xCC\x80\xCE\xA5\xCC\x93\xCC\x80\x08\x80\0\x06\x0C\xCF\x85\xCC\x93\xCC\x81\xCE\xA5\xCC\x93\xCC\x81\xCE\xA5\xCC\x93\xCC\x81\x08\x80\0\x06\x0C\xCF\x85\xCC\x93\xCD\x82\xCE\xA5\xCC\x93\xCD\x82\xCE\xA5\xCC\x93\xCD\x82\x08\x90\x08\0\x05\n\xE1\xBC\x80\xCE\xB9\xE1\xBC\x88\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x81\xCE\xB9\xE1\xBC\x89\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x82\xCE\xB9\xE1\xBC\x8A\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x83\xCE\xB9\xE1\xBC\x8B\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x84\xCE\xB9\xE1\xBC\x8C\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x85\xCE\xB9\xE1\xBC\x8D\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x86\xCE\xB9\xE1\xBC\x8E\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\x87\xCE\xB9\xE1\xBC\x8F\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x80\xCE\xB9\xE1\xBC\x88\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x81\xCE\xB9\xE1\xBC\x89\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x82\xCE\xB9\xE1\xBC\x8A\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x83\xCE\xB9\xE1\xBC\x8B\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x84\xCE\xB9\xE1\xBC\x8C\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x85\xCE\xB9\xE1\xBC\x8D\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x86\xCE\xB9\xE1\xBC\x8E\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\x87\xCE\xB9\xE1\xBC\x8F\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA0\xCE\xB9\xE1\xBC\xA8\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA1\xCE\xB9\xE1\xBC\xA9\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA2\xCE\xB9\xE1\xBC\xAA\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA3\xCE\xB9\xE1\xBC\xAB\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA4\xCE\xB9\xE1\xBC\xAC\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA5\xCE\xB9\xE1\xBC\xAD\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA6\xCE\xB9\xE1\xBC\xAE\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBC\xA7\xCE\xB9\xE1\xBC\xAF\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA0\xCE\xB9\xE1\xBC\xA8\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA1\xCE\xB9\xE1\xBC\xA9\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA2\xCE\xB9\xE1\xBC\xAA\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA3\xCE\xB9\xE1\xBC\xAB\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA4\xCE\xB9\xE1\xBC\xAC\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA5\xCE\xB9\xE1\xBC\xAD\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA6\xCE\xB9\xE1\xBC\xAE\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBC\xA7\xCE\xB9\xE1\xBC\xAF\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA0\xCE\xB9\xE1\xBD\xA8\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA1\xCE\xB9\xE1\xBD\xA9\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA2\xCE\xB9\xE1\xBD\xAA\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA3\xCE\xB9\xE1\xBD\xAB\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA4\xCE\xB9\xE1\xBD\xAC\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA5\xCE\xB9\xE1\xBD\xAD\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA6\xCE\xB9\xE1\xBD\xAE\xCE\x99\x08\x90\x08\0\x05\n\xE1\xBD\xA7\xCE\xB9\xE1\xBD\xAF\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA0\xCE\xB9\xE1\xBD\xA8\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA1\xCE\xB9\xE1\xBD\xA9\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA2\xCE\xB9\xE1\xBD\xAA\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA3\xCE\xB9\xE1\xBD\xAB\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA4\xCE\xB9\xE1\xBD\xAC\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA5\xCE\xB9\xE1\xBD\xAD\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA6\xCE\xB9\xE1\xBD\xAE\xCE\x99\x0C\x90\x08\0\x05\n\xE1\xBD\xA7\xCE\xB9\xE1\xBD\xAF\xCE\x99\x08\x80\0\x05\n\xE1\xBD\xB0\xCE\xB9\xE1\xBE\xBA\xCE\x99\xE1\xBE\xBA\xCD\x85\x08\x90\t\0\x04\x08\xCE\xB1\xCE\xB9\xCE\x91\xCE\x99\x08\x80\0\x04\x08\xCE\xAC\xCE\xB9\xCE\x86\xCE\x99\xCE\x86\xCD\x85\x08\x80\0\x04\x08\xCE\xB1\xCD\x82\xCE\x91\xCD\x82\xCE\x91\xCD\x82\x08\x80\0\x06\x0C\xCE\xB1\xCD\x82\xCE\xB9\xCE\x91\xCD\x82\xCE\x99\xCE\x91\xCD\x82\xCD\x85\x0C\x90\t\0\x04\x08\xCE\xB1\xCE\xB9\xCE\x91\xCE\x99\x08F\xCE\xB9\xCE\x99\xCD\x85\x08\x80\0\x05\n\xE1\xBD\xB4\xCE\xB9\xE1\xBF\x8A\xCE\x99\xE1\xBF\x8A\xCD\x85\x08\x90\t\0\x04\x08\xCE\xB7\xCE\xB9\xCE\x97\xCE\x99\x08\x80\0\x04\x08\xCE\xAE\xCE\xB9\xCE\x89\xCE\x99\xCE\x89\xCD\x85\x08\x80\0\x04\x08\xCE\xB7\xCD\x82\xCE\x97\xCD\x82\xCE\x97\xCD\x82\x08\x80\0\x06\x0C\xCE\xB7\xCD\x82\xCE\xB9\xCE\x97\xCD\x82\xCE\x99\xCE\x97\xCD\x82\xCD\x85\x0C\x90\t\0\x04\x08\xCE\xB7\xCE\xB9\xCE\x97\xCE\x99\x08\x80\0\x06\x0C\xCE\xB9\xCC\x88\xCC\x80\xCE\x99\xCC\x88\xCC\x80\xCE\x99\xCC\x88\xCC\x80\x08\x82\xCE\x90\0\x06\x0C\xCE\xB9\xCC\x88\xCC\x81\xCE\x99\xCC\x88\xCC\x81\xCE\x99\xCC\x88\xCC\x81\x08\x80\0\x04\x08\xCE\xB9\xCD\x82\xCE\x99\xCD\x82\xCE\x99\xCD\x82\x08\x80\0\x06\x0C\xCE\xB9\xCC\x88\xCD\x82\xCE\x99\xCC\x88\xCD\x82\xCE\x99\xCC\x88\xCD\x82\x08\x80\0\x06\x0C\xCF\x85\xCC\x88\xCC\x80\xCE\xA5\xCC\x88\xCC\x80\xCE\xA5\xCC\x88\xCC\x80\x08\x82\xCE\xB0\0\x06\x0C\xCF\x85\xCC\x88\xCC\x81\xCE\xA5\xCC\x88\xCC\x81\xCE\xA5\xCC\x88\xCC\x81\x08\x80\0\x04\x08\xCF\x81\xCC\x93\xCE\xA1\xCC\x93\xCE\xA1\xCC\x93\x08\x80\0\x04\x08\xCF\x85\xCD\x82\xCE\xA5\xCD\x82\xCE\xA5\xCD\x82\x08\x80\0\x06\x0C\xCF\x85\xCC\x88\xCD\x82\xCE\xA5\xCC\x88\xCD\x82\xCE\xA5\xCC\x88\xCD\x82\x08\x80\0\x05\n\xE1\xBD\xBC\xCE\xB9\xE1\xBF\xBA\xCE\x99\xE1\xBF\xBA\xCD\x85\x08\x90\t\0\x04\x08\xCF\x89\xCE\xB9\xCE\xA9\xCE\x99\x08\x80\0\x04\x08\xCF\x8E\xCE\xB9\xCE\x8F\xCE\x99\xCE\x8F\xCD\x85\x08\x80\0\x04\x08\xCF\x89\xCD\x82\xCE\xA9\xCD\x82\xCE\xA9\xCD\x82\x08\x80\0\x06\x0C\xCF\x89\xCD\x82\xCE\xB9\xCE\xA9\xCD\x82\xCE\x99\xCE\xA9\xCD\x82\xCD\x85\x0C\x90\t\0\x04\x08\xCF\x89\xCE\xB9\xCE\xA9\xCE\x99\x0CP\xE1\xB5\x9D\xCE\xA9\x0CP\xE2\x82\xBFK\x0CP\xE2\x81\x86\xC3\x85\x0C\x10\xE2\xA7\xB7\x0C\x10\xE0\xBB\xA6\x0C\x10\xE2\xA7\xA7\x0C\x10\xE2\xA8\xAB\x0C\x10\xE2\xA8\xA8\x0C\x10\xE2\xA8\x9C\x0C\x10\xE2\xA7\xBD\x0C\x10\xE2\xA8\x9F\x0C\x10\xE2\xA8\x9E\x0C\x10\xE2\xA8\xBF\x0C\x10\xE1\xB1\xA0\x08A\xEA\x99\x8B\xE1\xB2\x88\x08D\xEA\x99\x8A\xE1\xB2\x88\x0C\x10\xE8\xA8\x84\x0C\x10\xEA\x94\xA8\x0C\x10\xEA\x95\x84\x0C\x10\xEA\x95\x8F\x0C\x10\xEA\x95\x8B\x0C\x10\xEA\x95\x81\x0C\x10\xEA\x94\x92\x0C\x10\xEA\x94\xAA\x0C\x10\xEA\x94\x95\x08\x10\xCE\xA0\x0C\x10\xEA\x95\x83\x0C\x10\xE8\xA8\xB8\x0C\x10\xEA\x95\xA7\x0C\x10\xEA\x99\x81\x0C\x10\xCE\xA0\x08\x06\xE1\x8E\xA0\xE1\x8E\xA0\x08\x06\xE1\x8E\xA1\xE1\x8E\xA1\x08\x06\xE1\x8E\xA2\xE1\x8E\xA2\x08\x06\xE1\x8E\xA3\xE1\x8E\xA3\x08\x06\xE1\x8E\xA4\xE1\x8E\xA4\x08\x06\xE1\x8E\xA5\xE1\x8E\xA5\x08\x06\xE1\x8E\xA6\xE1\x8E\xA6\x08\x06\xE1\x8E\xA7\xE1\x8E\xA7\x08\x06\xE1\x8E\xA8\xE1\x8E\xA8\x08\x06\xE1\x8E\xA9\xE1\x8E\xA9\x08\x06\xE1\x8E\xAA\xE1\x8E\xAA\x08\x06\xE1\x8E\xAB\xE1\x8E\xAB\x08\x06\xE1\x8E\xAC\xE1\x8E\xAC\x08\x06\xE1\x8E\xAD\xE1\x8E\xAD\x08\x06\xE1\x8E\xAE\xE1\x8E\xAE\x08\x06\xE1\x8E\xAF\xE1\x8E\xAF\x08\x06\xE1\x8E\xB0\xE1\x8E\xB0\x08\x06\xE1\x8E\xB1\xE1\x8E\xB1\x08\x06\xE1\x8E\xB2\xE1\x8E\xB2\x08\x06\xE1\x8E\xB3\xE1\x8E\xB3\x08\x06\xE1\x8E\xB4\xE1\x8E\xB4\x08\x06\xE1\x8E\xB5\xE1\x8E\xB5\x08\x06\xE1\x8E\xB6\xE1\x8E\xB6\x08\x06\xE1\x8E\xB7\xE1\x8E\xB7\x08\x06\xE1\x8E\xB8\xE1\x8E\xB8\x08\x06\xE1\x8E\xB9\xE1\x8E\xB9\x08\x06\xE1\x8E\xBA\xE1\x8E\xBA\x08\x06\xE1\x8E\xBB\xE1\x8E\xBB\x08\x06\xE1\x8E\xBC\xE1\x8E\xBC\x08\x06\xE1\x8E\xBD\xE1\x8E\xBD\x08\x06\xE1\x8E\xBE\xE1\x8E\xBE\x08\x06\xE1\x8E\xBF\xE1\x8E\xBF\x08\x06\xE1\x8F\x80\xE1\x8F\x80\x08\x06\xE1\x8F\x81\xE1\x8F\x81\x08\x06\xE1\x8F\x82\xE1\x8F\x82\x08\x06\xE1\x8F\x83\xE1\x8F\x83\x08\x06\xE1\x8F\x84\xE1\x8F\x84\x08\x06\xE1\x8F\x85\xE1\x8F\x85\x08\x06\xE1\x8F\x86\xE1\x8F\x86\x08\x06\xE1\x8F\x87\xE1\x8F\x87\x08\x06\xE1\x8F\x88\xE1\x8F\x88\x08\x06\xE1\x8F\x89\xE1\x8F\x89\x08\x06\xE1\x8F\x8A\xE1\x8F\x8A\x08\x06\xE1\x8F\x8B\xE1\x8F\x8B\x08\x06\xE1\x8F\x8C\xE1\x8F\x8C\x08\x06\xE1\x8F\x8D\xE1\x8F\x8D\x08\x06\xE1\x8F\x8E\xE1\x8F\x8E\x08\x06\xE1\x8F\x8F\xE1\x8F\x8F\x08\x06\xE1\x8F\x90\xE1\x8F\x90\x08\x06\xE1\x8F\x91\xE1\x8F\x91\x08\x06\xE1\x8F\x92\xE1\x8F\x92\x08\x06\xE1\x8F\x93\xE1\x8F\x93\x08\x06\xE1\x8F\x94\xE1\x8F\x94\x08\x06\xE1\x8F\x95\xE1\x8F\x95\x08\x06\xE1\x8F\x96\xE1\x8F\x96\x08\x06\xE1\x8F\x97\xE1\x8F\x97\x08\x06\xE1\x8F\x98\xE1\x8F\x98\x08\x06\xE1\x8F\x99\xE1\x8F\x99\x08\x06\xE1\x8F\x9A\xE1\x8F\x9A\x08\x06\xE1\x8F\x9B\xE1\x8F\x9B\x08\x06\xE1\x8F\x9C\xE1\x8F\x9C\x08\x06\xE1\x8F\x9D\xE1\x8F\x9D\x08\x06\xE1\x8F\x9E\xE1\x8F\x9E\x08\x06\xE1\x8F\x9F\xE1\x8F\x9F\x08\x06\xE1\x8F\xA0\xE1\x8F\xA0\x08\x06\xE1\x8F\xA1\xE1\x8F\xA1\x08\x06\xE1\x8F\xA2\xE1\x8F\xA2\x08\x06\xE1\x8F\xA3\xE1\x8F\xA3\x08\x06\xE1\x8F\xA4\xE1\x8F\xA4\x08\x06\xE1\x8F\xA5\xE1\x8F\xA5\x08\x06\xE1\x8F\xA6\xE1\x8F\xA6\x08\x06\xE1\x8F\xA7\xE1\x8F\xA7\x08\x06\xE1\x8F\xA8\xE1\x8F\xA8\x08\x06\xE1\x8F\xA9\xE1\x8F\xA9\x08\x06\xE1\x8F\xAA\xE1\x8F\xAA\x08\x06\xE1\x8F\xAB\xE1\x8F\xAB\x08\x06\xE1\x8F\xAC\xE1\x8F\xAC\x08\x06\xE1\x8F\xAD\xE1\x8F\xAD\x08\x06\xE1\x8F\xAE\xE1\x8F\xAE\x08\x06\xE1\x8F\xAF\xE1\x8F\xAF\x08\x80\0\x02\x04ffFFFf\x08\x80\0\x02\x04fiFIFi\x08\x80\0\x02\x04flFLFl\x08\x80\0\x03\x06ffiFFIFfi\x08\x80\0\x03\x06fflFFLFfl\x08\x82\xEF\xAC\x86\0\x02\x04stSTSt\x08\xC0\x03\xEF\xAC\x85\0\x02\x04stSTSt\x08\x80\0\x04\x08\xD5\xB4\xD5\xB6\xD5\x84\xD5\x86\xD5\x84\xD5\xB6\x08\x80\0\x04\x08\xD5\xB4\xD5\xA5\xD5\x84\xD4\xB5\xD5\x84\xD5\xA5\x08\x80\0\x04\x08\xD5\xB4\xD5\xAB\xD5\x84\xD4\xBB\xD5\x84\xD5\xAB\x08\x80\0\x04\x08\xD5\xBE\xD5\xB6\xD5\x8E\xD5\x86\xD5\x8E\xD5\xB6\x08\x80\0\x04\x08\xD5\xB4\xD5\xAD\xD5\x84\xD4\xBD\xD5\x84\xD5\xAD") } } };
+        }
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::DataProvider<icu::casemap::provider::CaseMapV1> for $provider {
+            fn load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponse<icu::casemap::provider::CaseMapV1>, icu_provider::DataError> {
+                if req.id.locale.is_unknown() {
+                    Ok(icu_provider::DataResponse { payload: icu_provider::DataPayload::from_static_ref(Self::SINGLETON_CASE_MAP_V1), metadata: icu_provider::DataResponseMetadata::default() })
+                } else {
+                    Err(icu_provider::DataErrorKind::InvalidRequest.with_req(<icu::casemap::provider::CaseMapV1 as icu_provider::DataMarker>::INFO, req))
+                }
+            }
+        }
+    };
+    ($ provider : ty , ITER) => {
+        __impl_case_map_v1!($provider);
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::IterableDataProvider<icu::casemap::provider::CaseMapV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BtreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok([Default::default()].into_iter().collect())
+            }
+        }
+    };
+    ($ provider : ty , DRY) => {
+        __impl_case_map_v1!($provider);
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::DryDataProvider<icu::casemap::provider::CaseMapV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                if req.id.locale.is_unknown() {
+                    Ok(icu_provider::DataResponseMetadata::default())
+                } else {
+                    Err(icu_provider::DataErrorKind::InvalidRequest.with_req(<icu::casemap::provider::CaseMapV1 as icu_provider::DataMarker>::INFO, req))
+                }
+            }
+        }
+    };
+    ($ provider : ty , DRY , ITER) => {
+        __impl_case_map_v1!($provider);
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::DryDataProvider<icu::casemap::provider::CaseMapV1> for $provider {
+            fn dry_load(&self, req: icu_provider::DataRequest) -> Result<icu_provider::DataResponseMetadata, icu_provider::DataError> {
+                if req.id.locale.is_unknown() {
+                    Ok(icu_provider::DataResponseMetadata::default())
+                } else {
+                    Err(icu_provider::DataErrorKind::InvalidRequest.with_req(<icu::casemap::provider::CaseMapV1 as icu_provider::DataMarker>::INFO, req))
+                }
+            }
+        }
+        #[clippy::msrv = "1.82"]
+        impl icu_provider::IterableDataProvider<icu::casemap::provider::CaseMapV1> for $provider {
+            fn iter_ids(&self) -> Result<std::collections::BtreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                Ok([Default::default()].into_iter().collect())
+            }
+        }
+    };
+}
+#[doc(inline)]
+pub use __impl_case_map_v1 as impl_case_map_v1;
diff --git a/third_party/rust/icu_casemap_data/data/mod.rs b/third_party/rust/icu_casemap_data/data/mod.rs
@@ -0,0 +1,36 @@
+// @generated
+include!("case_map_unfold_v1.rs.data");
+include!("case_map_v1.rs.data");
+/// Marks a type as a data provider. You can then use macros like
+/// `impl_core_helloworld_v1` to add implementations.
+///
+/// ```ignore
+/// struct MyProvider;
+/// const _: () = {
+///     include!("path/to/generated/macros.rs");
+///     make_provider!(MyProvider);
+///     impl_core_helloworld_v1!(MyProvider);
+/// }
+/// ```
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __make_provider {
+    ($ name : ty) => {
+        #[clippy::msrv = "1.82"]
+        impl $name {
+            #[allow(dead_code)]
+            pub(crate) const MUST_USE_MAKE_PROVIDER_MACRO: () = ();
+        }
+        icu_provider::marker::impl_data_provider_never_marker!($name);
+    };
+}
+#[doc(inline)]
+pub use __make_provider as make_provider;
+#[allow(unused_macros)]
+macro_rules! impl_data_provider {
+    ($ provider : ty) => {
+        make_provider!($provider);
+        impl_case_map_unfold_v1!($provider);
+        impl_case_map_v1!($provider);
+    };
+}
diff --git a/third_party/rust/icu_casemap_data/src/lib.rs b/third_party/rust/icu_casemap_data/src/lib.rs
@@ -0,0 +1,17 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! Data for the `icu_casemap` crate
+//!
+//! This data was generated with CLDR version 47.0.0, ICU version icu4x/2025-05-01/77.x, and
+//! LSTM segmenter version v0.1.0.
+
+#![no_std]
+// The source is not readable and is massive as HTML.
+#![doc(html_no_source)]
+
+#[cfg(icu4x_custom_data)]
+include!(concat!(core::env!("ICU4X_DATA_DIR"), "/mod.rs"));
+#[cfg(not(icu4x_custom_data))]
+include!("../data/mod.rs");
diff --git a/third_party/rust/nss/.cargo-checksum.json b/third_party/rust/nss/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"a02789df36131f32a60b54968c08b6cb77b75735011d2d4a8932b4f538ddd139","README.md":"14dd59e435d179c21c3b4b880bbe3cc6e5999b9f9ac9431f3f9aa3f43902e3fa","src/aes.rs":"bf3b115fecfc445fed978f43fed4076249c99d72db203acacd8297f418c347e5","src/cert.rs":"8195da7dc86bb9f60306106be08e622d0a116dabdbd31967e227435933ee50d0","src/ec.rs":"c495042a6f92254b7c9941ef0e253340922b0c1d1c43c7d3e725aa1068ae5d0b","src/ecdh.rs":"4acddfaebbc43f4e59c9dd0df56e582f5d0db65c4fd15dcc634c2e27d84efc2c","src/error.rs":"58a923bb8651160bb17c582cf876046792e79f3a190c8572f836b218f16cee74","src/lib.rs":"862ae2d8dbbe29f83579209286198b19bdccdcd81b99e55646d25de874a76d13","src/pbkdf2.rs":"40d5facfdc434571455283265823dd2b0334d2a8db0a09b50ee05d5b1f2a02d7","src/pk11/context.rs":"b4927fe401ed113d79f03aed1c0d9a007d3ce3b3706921ebc3e239e1f472dad6","src/pk11/mod.rs":"d78368654f9a8bc12f1403c4a096b63cf9834820ea6ed48418b9afaa0fc2299e","src/pk11/slot.rs":"99cb603b6d561b86d7655ca33da4aa0e4fb355d065f56d1bfc22b0778a745989","src/pk11/sym_key.rs":"e7c7c3314e7fb850264b7282193220e4bb125a399888aa45ab7a73ca1ede5753","src/pk11/types.rs":"010e926224d29c9fe12d8804add17e2130f4c383bc8186ac1dad08d16678ae4e","src/pkixc.rs":"939fd8bd84be5eef57c6e9a970e1509e8cb94566ad42f1427a3beaaa214cc62b","src/secport.rs":"99a2c5112939bda2558dd7f0760f1092ab42052871448181083f92ce56f73f05","src/util.rs":"5d19265429cb707dc51a7b712ae6f5dd013db0975d215a314a31e8110902f4a5"},"package":null}
-\ No newline at end of file
+{"files":{"Cargo.toml":"a02789df36131f32a60b54968c08b6cb77b75735011d2d4a8932b4f538ddd139","README.md":"14dd59e435d179c21c3b4b880bbe3cc6e5999b9f9ac9431f3f9aa3f43902e3fa","src/aes.rs":"bf3b115fecfc445fed978f43fed4076249c99d72db203acacd8297f418c347e5","src/cert.rs":"8195da7dc86bb9f60306106be08e622d0a116dabdbd31967e227435933ee50d0","src/ec.rs":"c495042a6f92254b7c9941ef0e253340922b0c1d1c43c7d3e725aa1068ae5d0b","src/ecdh.rs":"4acddfaebbc43f4e59c9dd0df56e582f5d0db65c4fd15dcc634c2e27d84efc2c","src/error.rs":"58a923bb8651160bb17c582cf876046792e79f3a190c8572f836b218f16cee74","src/lib.rs":"862ae2d8dbbe29f83579209286198b19bdccdcd81b99e55646d25de874a76d13","src/pbkdf2.rs":"40d5facfdc434571455283265823dd2b0334d2a8db0a09b50ee05d5b1f2a02d7","src/pk11/context.rs":"b4927fe401ed113d79f03aed1c0d9a007d3ce3b3706921ebc3e239e1f472dad6","src/pk11/mod.rs":"d78368654f9a8bc12f1403c4a096b63cf9834820ea6ed48418b9afaa0fc2299e","src/pk11/slot.rs":"99cb603b6d561b86d7655ca33da4aa0e4fb355d065f56d1bfc22b0778a745989","src/pk11/sym_key.rs":"aadfc3a616711756443ffb3cea304a7286da27a4177d9938def1eb1a4a9e71eb","src/pk11/types.rs":"010e926224d29c9fe12d8804add17e2130f4c383bc8186ac1dad08d16678ae4e","src/pkixc.rs":"939fd8bd84be5eef57c6e9a970e1509e8cb94566ad42f1427a3beaaa214cc62b","src/secport.rs":"99a2c5112939bda2558dd7f0760f1092ab42052871448181083f92ce56f73f05","src/util.rs":"5d19265429cb707dc51a7b712ae6f5dd013db0975d215a314a31e8110902f4a5"},"package":null}
+\ No newline at end of file
diff --git a/third_party/rust/nss/src/pk11/sym_key.rs b/third_party/rust/nss/src/pk11/sym_key.rs
@@ -191,8 +191,11 @@ fn get_aes256_key(name: &str) -> Result<SymKey> {
                 return Err(ErrorKind::InvalidKeyLength.into());
             }
             // Allocate an extra 8 bytes for CKM_AES_KEY_WRAP_KWP overhead.
-            let wrapped_key = unsafe {
-                nss_sys::SECITEM_AllocItem(ptr::null_mut(), ptr::null_mut(), wrap_len.len + 8)
+            let mut buf = vec![0; (wrap_len.len + 8).try_into().expect("invalid key length")];
+            let mut wrapped_key = nss_sys::SECItem {
+                type_: nss_sys::SECItemType::siBuffer as u32,
+                data: buf.as_mut_ptr(),
+                len: buf.len() as u32,
             };
             map_nss_secstatus(|| unsafe {
                 nss_sys::PK11_WrapSymKey(
@@ -200,7 +203,7 @@ fn get_aes256_key(name: &str) -> Result<SymKey> {
                     ptr::null_mut(),
                     wrapping_key.as_mut_ptr(),
                     sym_key.as_mut_ptr(),
-                    wrapped_key,
+                    &mut wrapped_key,
                 )
             })
             .map_err(|_| get_last_error())?;
@@ -209,7 +212,7 @@ fn get_aes256_key(name: &str) -> Result<SymKey> {
                     wrapping_key.as_mut_ptr(),
                     nss_sys::CKM_AES_KEY_WRAP_KWP,
                     ptr::null_mut(),
-                    wrapped_key,
+                    &mut wrapped_key,
                     nss_sys::CKM_AES_GCM.into(),
                     (nss_sys::CKA_ENCRYPT | nss_sys::CKA_DECRYPT).into(),
                     wrap_len.len as i32,
@@ -217,14 +220,6 @@ fn get_aes256_key(name: &str) -> Result<SymKey> {
             }
             .map_err(|_| get_last_error())?;
 
-            // This cleanup will not run if a previous operation fails and causes an early return.
-            // Using an RAII-style wrapper would be preferable to ensure the item is always freed,
-            // but given that an earlier failure likely prevents startup, it is acceptable.
-            //
-            // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1992756 for a follow-up
-            // improvement.
-            unsafe { nss_sys::SECITEM_FreeItem(wrapped_key, nss_sys::PR_TRUE) }
-
             map_nss_secstatus(|| unsafe { nss_sys::PK11_ExtractKeyValue(sym_key.as_mut_ptr()) })?;
             Ok(sym_key)
         }
diff --git a/third_party/rust/nss_sys/.cargo-checksum.json b/third_party/rust/nss_sys/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"fadb4d4c210bd6bfb89552c4421f22151acdbbc1fc72f4eb97c7bceb271385e8","README.md":"5f931f614978589f2343ad2ae405e21ccf49496d4593f3fec818b1a9bc2f194b","build.rs":"b541496d108a9e85545b9ee28c84790aa5b361805f691a082403233588423fd0","src/bindings/blapit.rs":"9f83f4d66c7164f75d714ea569714a36c2d2e9fda981e3aa1b890c54567c9e79","src/bindings/certdb.rs":"00411907215d7b427952a0200f91e4c564158fc5883cdb7332d92afcb424375b","src/bindings/keyhi.rs":"cdf9c3735343a718f86cfe5f822530dc7c7e4fc2c36e2a11797d9054dd0bfd05","src/bindings/keythi.rs":"ea9a1a8c33c3f2b8b78bd58d8d627d9f8d8c22ee4e1cd26c78701106bf0db69f","src/bindings/mod.rs":"c5cefb78172bd7bc1650123edf92f7005bb5e74ed090beaa73772c1b2fd26cf6","src/bindings/nss.rs":"c221cfcdaf00e9e024b335ff137d4df5feca5d3e30af0fe680e6feac33450ed7","src/bindings/pk11pub.rs":"c49d433cc87a9039ee5a278ca0a1e8d90c2406f1d05bc0001be2eb9e34b6ca53","src/bindings/pkcs11n.rs":"bc1ba0d903891d5331aeb6b1921fde7c2cd31cbbe75338e145b5aaff5c94c147","src/bindings/pkcs11t.rs":"5d84bfd36df100b026b6ddf4c48b75f2b0f3475108ba309985341c228f9e6955","src/bindings/pkixc.rs":"61d2bf93ad07ada57338dbf4f3418f782502e76a316759044ab20e80c284016d","src/bindings/plarena.rs":"8de09e3c378df457988729ca4d58e1ef1f2883dfa68e62acb79a55fb19a9d6f5","src/bindings/prerror.rs":"b7bda8a6511c43f59351a17f4311ceb272231a55473895b999a34e3a3ff76722","src/bindings/prtypes.rs":"5afd17e4d24880609320f8cc5a9c06f57ac766524ca5f6cbc5edc65195974c6e","src/bindings/secasn1t.rs":"5a79f0a4057fb934786ef9407c7b134c7bc2f3560f9af0d58dd27ede62c66391","src/bindings/seccomon.rs":"1538dc6226e3c731e3028b6e3859de7f51c7bf996b0a48e9019c766187c61576","src/bindings/secitem.rs":"7a1593f87dcbb4d9ef462fda9932486d169bea9f12b4ed83e3a7102d0b33127e","src/bindings/seckey.rs":"dd7b90e263c19855e38f6df657d60c532a509a3a9180acddc8f5f612da76889b","src/bindings/secmodt.rs":"f1c002df25b598e6fbed5285c98c0d8cfe4188254ca31f829cb993d321a4f6d0","src/bindings/secoid.rs":"1a1e3d8106c26d081daa56b22f6214b6b2456e14f6d5b34db77bb428e7dc4525","src/bindings/secoidt.rs":"d3841fa00100d081fd355ef65d8ff10e2341440715c937017d795fc7efd0d31d","src/bindings/secport.rs":"6b9c691f7a80467ad2db76e2168d9dceee781e5edaadd48b76e66852f632db12","src/lib.rs":"3081488f34b747cbe852e6692389db5df3dae65b180558aa7af9bf6ae809faa2"},"package":null}
-\ No newline at end of file
+{"files":{"Cargo.toml":"fadb4d4c210bd6bfb89552c4421f22151acdbbc1fc72f4eb97c7bceb271385e8","README.md":"5f931f614978589f2343ad2ae405e21ccf49496d4593f3fec818b1a9bc2f194b","build.rs":"b541496d108a9e85545b9ee28c84790aa5b361805f691a082403233588423fd0","src/bindings/blapit.rs":"9f83f4d66c7164f75d714ea569714a36c2d2e9fda981e3aa1b890c54567c9e79","src/bindings/certdb.rs":"00411907215d7b427952a0200f91e4c564158fc5883cdb7332d92afcb424375b","src/bindings/keyhi.rs":"cdf9c3735343a718f86cfe5f822530dc7c7e4fc2c36e2a11797d9054dd0bfd05","src/bindings/keythi.rs":"ea9a1a8c33c3f2b8b78bd58d8d627d9f8d8c22ee4e1cd26c78701106bf0db69f","src/bindings/mod.rs":"c5cefb78172bd7bc1650123edf92f7005bb5e74ed090beaa73772c1b2fd26cf6","src/bindings/nss.rs":"c221cfcdaf00e9e024b335ff137d4df5feca5d3e30af0fe680e6feac33450ed7","src/bindings/pk11pub.rs":"9b6b2a533f7ed373ea7ff34116abbbcbb2c6c5da351fb0e50309d94007e48bea","src/bindings/pkcs11n.rs":"bc1ba0d903891d5331aeb6b1921fde7c2cd31cbbe75338e145b5aaff5c94c147","src/bindings/pkcs11t.rs":"5d84bfd36df100b026b6ddf4c48b75f2b0f3475108ba309985341c228f9e6955","src/bindings/pkixc.rs":"61d2bf93ad07ada57338dbf4f3418f782502e76a316759044ab20e80c284016d","src/bindings/plarena.rs":"8de09e3c378df457988729ca4d58e1ef1f2883dfa68e62acb79a55fb19a9d6f5","src/bindings/prerror.rs":"b7bda8a6511c43f59351a17f4311ceb272231a55473895b999a34e3a3ff76722","src/bindings/prtypes.rs":"5afd17e4d24880609320f8cc5a9c06f57ac766524ca5f6cbc5edc65195974c6e","src/bindings/secasn1t.rs":"5a79f0a4057fb934786ef9407c7b134c7bc2f3560f9af0d58dd27ede62c66391","src/bindings/seccomon.rs":"1538dc6226e3c731e3028b6e3859de7f51c7bf996b0a48e9019c766187c61576","src/bindings/secitem.rs":"7a1593f87dcbb4d9ef462fda9932486d169bea9f12b4ed83e3a7102d0b33127e","src/bindings/seckey.rs":"dd7b90e263c19855e38f6df657d60c532a509a3a9180acddc8f5f612da76889b","src/bindings/secmodt.rs":"f1c002df25b598e6fbed5285c98c0d8cfe4188254ca31f829cb993d321a4f6d0","src/bindings/secoid.rs":"1a1e3d8106c26d081daa56b22f6214b6b2456e14f6d5b34db77bb428e7dc4525","src/bindings/secoidt.rs":"d3841fa00100d081fd355ef65d8ff10e2341440715c937017d795fc7efd0d31d","src/bindings/secport.rs":"6b9c691f7a80467ad2db76e2168d9dceee781e5edaadd48b76e66852f632db12","src/lib.rs":"3081488f34b747cbe852e6692389db5df3dae65b180558aa7af9bf6ae809faa2"},"package":null}
+\ No newline at end of file
diff --git a/third_party/rust/nss_sys/src/bindings/pk11pub.rs b/third_party/rust/nss_sys/src/bindings/pk11pub.rs
@@ -183,9 +183,4 @@ extern "C" {
         faulty3DES: PRBool,
         wincx: *mut c_void,
     ) -> *mut PK11SymKey;
-    pub fn SECITEM_AllocItem(
-        arena: *mut PLArenaPool,
-        item: *mut SECItem,
-        len: c_uint,
-    ) -> *mut SECItem;
 }
diff --git a/third_party/rust/prost-derive/.cargo-checksum.json b/third_party/rust/prost-derive/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"7d555d8783ebeebdb3c3190ff57fa833db7cbd14eecba8a5a101f87e7dca3f71","LICENSE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","README.md":"6c67fa1e48f14adfaf834f520f798ddfb79f90804f46cc215ee391a7d57913a4","src/field/group.rs":"0370fda09a6dc7e8e91cfab1a6638c0117f0b968bcc7d1a8f397c2bf00042481","src/field/map.rs":"a03791fc758802cdf4e75e197acd7975141377e3d1ad1273e6cefab2b7fddfe9","src/field/message.rs":"a5672412435bb9fafbd4a99b1a6c6d5bbf636a571959358a44196bfd69efc2d1","src/field/mod.rs":"108b98c676b780fbe55907a3c2825bdf77cd0f857292bfa82a78f5b20fa499c5","src/field/oneof.rs":"128e990b8bb711fdbadd35b711f127c02f64b84b5ca95307b428956896d15721","src/field/scalar.rs":"16a4210578e7e643d49b5c769078f8bf295dae738f3ba2b6e48af7291b9e7951","src/lib.rs":"0b86c9fdace3d3f942afad55f7aa21d4dc2c7d8447906d03fd9c650d311c47ee"},"package":"265baba7fabd416cf5078179f7d2cbeca4ce7a9041111900675ea7c4cb8a4c32"}
-\ No newline at end of file
+{"files":{"Cargo.lock":"bbc5a09c69c9cb2e444a0ecd705029859e400960a98bea91bedbefadae8513ae","Cargo.toml":"29f1603fcfa32eac2af03353bb54a579dd491b5fedfc3150ca094e47290cd8e5","LICENSE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","README.md":"6c67fa1e48f14adfaf834f520f798ddfb79f90804f46cc215ee391a7d57913a4","src/field/group.rs":"0e2a468af54d9082d858f18d5276fd549349f0048d9aaf41a3493018a811d962","src/field/map.rs":"a03791fc758802cdf4e75e197acd7975141377e3d1ad1273e6cefab2b7fddfe9","src/field/message.rs":"736e160b4e470dc6d0f2fcbf12e704c590bc1880e5fe08933c440f1cf2e767b1","src/field/mod.rs":"541c1a346a0ff4fcb4610a5c9d379e99a7dbfe8981e5c1c902ddf6c395dfda0a","src/field/oneof.rs":"c0a55cb194d9651cbc63c2a19243a7e5fc197c170a9f44af87b30b07bad21b4e","src/field/scalar.rs":"61150549be0de070845018ae5aef8c42bebdae033e4e251bddbd0bd2a892c501","src/lib.rs":"f7604825f524995f110077d35c499d7515789c08ac40b5ed5dbcb84c157a5605"},"package":"8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"}
+\ No newline at end of file
diff --git a/third_party/rust/prost-derive/Cargo.lock b/third_party/rust/prost-derive/Cargo.lock
@@ -0,0 +1,70 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
+
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.5"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
diff --git a/third_party/rust/prost-derive/Cargo.toml b/third_party/rust/prost-derive/Cargo.toml
@@ -11,33 +11,39 @@
 
 [package]
 edition = "2021"
-rust-version = "1.60"
+rust-version = "1.71.1"
 name = "prost-derive"
-version = "0.12.1"
+version = "0.13.5"
 authors = [
     "Dan Burkert <dan@danburkert.com>",
     "Lucio Franco <luciofranco14@gmail.com>",
+    "Casper Meijn <casper@meijn.net>",
     "Tokio Contributors <team@tokio.rs>",
 ]
-description = "A Protocol Buffers implementation for the Rust Language."
-documentation = "https://docs.rs/prost-derive"
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Generate encoding and decoding implementations for Prost annotated types."
 readme = "README.md"
 license = "Apache-2.0"
 repository = "https://github.com/tokio-rs/prost"
 
 [lib]
-proc_macro = true
+name = "prost_derive"
+path = "src/lib.rs"
+proc-macro = true
 
 [dependencies.anyhow]
 version = "1.0.1"
 
 [dependencies.itertools]
-version = ">=0.10, <0.12"
-features = ["use_alloc"]
-default-features = false
+version = ">=0.10.1, <=0.14"
 
 [dependencies.proc-macro2]
-version = "1"
+version = "1.0.60"
 
 [dependencies.quote]
 version = "1"
diff --git a/third_party/rust/prost-derive/src/field/group.rs b/third_party/rust/prost-derive/src/field/group.rs
@@ -38,10 +38,11 @@ impl Field {
             return Ok(None);
         }
 
-        match unknown_attrs.len() {
-            0 => (),
-            1 => bail!("unknown attribute for group field: {:?}", unknown_attrs[0]),
-            _ => bail!("unknown attributes for group field: {:?}", unknown_attrs),
+        if !unknown_attrs.is_empty() {
+            bail!(
+                "unknown attribute(s) for group field: #[prost({})]",
+                quote!(#(#unknown_attrs),*)
+            );
         }
 
         let tag = match tag.or(inferred_tag) {
diff --git a/third_party/rust/prost-derive/src/field/message.rs b/third_party/rust/prost-derive/src/field/message.rs
@@ -38,13 +38,11 @@ impl Field {
             return Ok(None);
         }
 
-        match unknown_attrs.len() {
-            0 => (),
-            1 => bail!(
-                "unknown attribute for message field: {:?}",
-                unknown_attrs[0]
-            ),
-            _ => bail!("unknown attributes for message field: {:?}", unknown_attrs),
+        if !unknown_attrs.is_empty() {
+            bail!(
+                "unknown attribute(s) for message field: #[prost({})]",
+                quote!(#(#unknown_attrs),*)
+            );
         }
 
         let tag = match tag.or(inferred_tag) {
diff --git a/third_party/rust/prost-derive/src/field/mod.rs b/third_party/rust/prost-derive/src/field/mod.rs
@@ -269,9 +269,7 @@ fn bool_attr(key: &str, attr: &Meta) -> Result<Option<bool>, Error> {
     }
     match *attr {
         Meta::Path(..) => Ok(Some(true)),
-        Meta::List(ref meta_list) => {
-            return Ok(Some(meta_list.parse_args::<LitBool>()?.value()));
-        }
+        Meta::List(ref meta_list) => Ok(Some(meta_list.parse_args::<LitBool>()?.value())),
         Meta::NameValue(MetaNameValue {
             value:
                 Expr::Lit(ExprLit {
@@ -310,9 +308,7 @@ pub(super) fn tag_attr(attr: &Meta) -> Result<Option<u32>, Error> {
         return Ok(None);
     }
     match *attr {
-        Meta::List(ref meta_list) => {
-            return Ok(Some(meta_list.parse_args::<LitInt>()?.base10_parse()?));
-        }
+        Meta::List(ref meta_list) => Ok(Some(meta_list.parse_args::<LitInt>()?.base10_parse()?)),
         Meta::NameValue(MetaNameValue {
             value: Expr::Lit(ref expr),
             ..
diff --git a/third_party/rust/prost-derive/src/field/oneof.rs b/third_party/rust/prost-derive/src/field/oneof.rs
@@ -44,13 +44,11 @@ impl Field {
             None => return Ok(None),
         };
 
-        match unknown_attrs.len() {
-            0 => (),
-            1 => bail!(
-                "unknown attribute for message field: {:?}",
-                unknown_attrs[0]
-            ),
-            _ => bail!("unknown attributes for message field: {:?}", unknown_attrs),
+        if !unknown_attrs.is_empty() {
+            bail!(
+                "unknown attribute(s) for message field: #[prost({})]",
+                quote!(#(#unknown_attrs),*)
+            );
         }
 
         let tags = match tags {
diff --git a/third_party/rust/prost-derive/src/field/scalar.rs b/third_party/rust/prost-derive/src/field/scalar.rs
@@ -1,4 +1,3 @@
-use std::convert::TryFrom;
 use std::fmt;
 
 use anyhow::{anyhow, bail, Error};
@@ -47,10 +46,11 @@ impl Field {
             None => return Ok(None),
         };
 
-        match unknown_attrs.len() {
-            0 => (),
-            1 => bail!("unknown attribute: {:?}", unknown_attrs[0]),
-            _ => bail!("unknown attributes: {:?}", unknown_attrs),
+        if !unknown_attrs.is_empty() {
+            bail!(
+                "unknown attribute(s): #[prost({})]",
+                quote!(#(#unknown_attrs),*)
+            );
         }
 
         let tag = match tag.or(inferred_tag) {
@@ -272,7 +272,7 @@ impl Field {
     pub fn methods(&self, ident: &TokenStream) -> Option<TokenStream> {
         let mut ident_str = ident.to_string();
         if ident_str.starts_with("r#") {
-            ident_str = ident_str[2..].to_owned();
+            ident_str = ident_str.split_off(2);
         }
 
         // Prepend `get_` for getter methods of tuple structs.
diff --git a/third_party/rust/prost-derive/src/lib.rs b/third_party/rust/prost-derive/src/lib.rs
@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/prost-derive/0.12.1")]
+#![doc(html_root_url = "https://docs.rs/prost-derive/0.13.5")]
 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "4096"]
 
@@ -7,8 +7,7 @@ extern crate proc_macro;
 
 use anyhow::{bail, Error};
 use itertools::Itertools;
-use proc_macro::TokenStream;
-use proc_macro2::Span;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
     punctuated::Punctuated, Data, DataEnum, DataStruct, DeriveInput, Expr, Fields, FieldsNamed,
@@ -19,7 +18,7 @@ mod field;
 use crate::field::Field;
 
 fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
-    let input: DeriveInput = syn::parse(input)?;
+    let input: DeriveInput = syn::parse2(input)?;
 
     let ident = input.ident;
 
@@ -88,29 +87,31 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
     // TODO: This encodes oneof fields in the position of their lowest tag,
     // regardless of the currently occupied variant, is that consequential?
     // See: https://developers.google.com/protocol-buffers/docs/encoding#order
-    fields.sort_by_key(|&(_, ref field)| field.tags().into_iter().min().unwrap());
+    fields.sort_by_key(|(_, field)| field.tags().into_iter().min().unwrap());
     let fields = fields;
 
-    let mut tags = fields
+    if let Some(duplicate_tag) = fields
         .iter()
-        .flat_map(|&(_, ref field)| field.tags())
-        .collect::<Vec<_>>();
-    let num_tags = tags.len();
-    tags.sort_unstable();
-    tags.dedup();
-    if tags.len() != num_tags {
-        bail!("message {} has fields with duplicate tags", ident);
-    }
+        .flat_map(|(_, field)| field.tags())
+        .duplicates()
+        .next()
+    {
+        bail!(
+            "message {} has multiple fields with tag {}",
+            ident,
+            duplicate_tag
+        )
+    };
 
     let encoded_len = fields
         .iter()
-        .map(|&(ref field_ident, ref field)| field.encoded_len(quote!(self.#field_ident)));
+        .map(|(field_ident, field)| field.encoded_len(quote!(self.#field_ident)));
 
     let encode = fields
         .iter()
-        .map(|&(ref field_ident, ref field)| field.encode(quote!(self.#field_ident)));
+        .map(|(field_ident, field)| field.encode(quote!(self.#field_ident)));
 
-    let merge = fields.iter().map(|&(ref field_ident, ref field)| {
+    let merge = fields.iter().map(|(field_ident, field)| {
         let merge = field.merge(quote!(value));
         let tags = field.tags().into_iter().map(|tag| quote!(#tag));
         let tags = Itertools::intersperse(tags, quote!(|));
@@ -136,7 +137,7 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
 
     let clear = fields
         .iter()
-        .map(|&(ref field_ident, ref field)| field.clear(quote!(self.#field_ident)));
+        .map(|(field_ident, field)| field.clear(quote!(self.#field_ident)));
 
     let default = if is_struct {
         let default = fields.iter().map(|(field_ident, field)| {
@@ -158,7 +159,7 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
 
     let methods = fields
         .iter()
-        .flat_map(|&(ref field_ident, ref field)| field.methods(field_ident))
+        .flat_map(|(field_ident, field)| field.methods(field_ident))
         .collect::<Vec<_>>();
     let methods = if methods.is_empty() {
         quote!()
@@ -174,19 +175,19 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
     let expanded = quote! {
         impl #impl_generics ::prost::Message for #ident #ty_generics #where_clause {
             #[allow(unused_variables)]
-            fn encode_raw<B>(&self, buf: &mut B) where B: ::prost::bytes::BufMut {
+            fn encode_raw(&self, buf: &mut impl ::prost::bytes::BufMut) {
                 #(#encode)*
             }
 
             #[allow(unused_variables)]
-            fn merge_field<B>(
+            fn merge_field(
                 &mut self,
                 tag: u32,
-                wire_type: ::prost::encoding::WireType,
-                buf: &mut B,
+                wire_type: ::prost::encoding::wire_type::WireType,
+                buf: &mut impl ::prost::bytes::Buf,
                 ctx: ::prost::encoding::DecodeContext,
             ) -> ::core::result::Result<(), ::prost::DecodeError>
-            where B: ::prost::bytes::Buf {
+            {
                 #struct_name
                 match tag {
                     #(#merge)*
@@ -213,7 +214,7 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
     let expanded = if skip_debug {
         expanded
     } else {
-        let debugs = unsorted_fields.iter().map(|&(ref field_ident, ref field)| {
+        let debugs = unsorted_fields.iter().map(|(field_ident, field)| {
             let wrapper = field.debug(quote!(self.#field_ident));
             let call = if is_struct {
                 quote!(builder.field(stringify!(#field_ident), &wrapper))
@@ -251,16 +252,16 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
         #methods
     };
 
-    Ok(expanded.into())
+    Ok(expanded)
 }
 
 #[proc_macro_derive(Message, attributes(prost))]
-pub fn message(input: TokenStream) -> TokenStream {
-    try_message(input).unwrap()
+pub fn message(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    try_message(input.into()).unwrap().into()
 }
 
 fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
-    let input: DeriveInput = syn::parse(input)?;
+    let input: DeriveInput = syn::parse2(input)?;
     let ident = input.ident;
 
     let generics = &input.generics;
@@ -300,16 +301,14 @@ fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
 
     let default = variants[0].0.clone();
 
-    let is_valid = variants
+    let is_valid = variants.iter().map(|(_, value)| quote!(#value => true));
+    let from = variants
         .iter()
-        .map(|&(_, ref value)| quote!(#value => true));
-    let from = variants.iter().map(
-        |&(ref variant, ref value)| quote!(#value => ::core::option::Option::Some(#ident::#variant)),
-    );
+        .map(|(variant, value)| quote!(#value => ::core::option::Option::Some(#ident::#variant)));
 
-    let try_from = variants.iter().map(
-        |&(ref variant, ref value)| quote!(#value => ::core::result::Result::Ok(#ident::#variant)),
-    );
+    let try_from = variants
+        .iter()
+        .map(|(variant, value)| quote!(#value => ::core::result::Result::Ok(#ident::#variant)));
 
     let is_valid_doc = format!("Returns `true` if `value` is a variant of `{}`.", ident);
     let from_i32_doc = format!(
@@ -350,27 +349,27 @@ fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
         }
 
         impl #impl_generics ::core::convert::TryFrom::<i32> for #ident #ty_generics #where_clause {
-            type Error = ::prost::DecodeError;
+            type Error = ::prost::UnknownEnumValue;
 
-            fn try_from(value: i32) -> ::core::result::Result<#ident, ::prost::DecodeError> {
+            fn try_from(value: i32) -> ::core::result::Result<#ident, ::prost::UnknownEnumValue> {
                 match value {
                     #(#try_from,)*
-                    _ => ::core::result::Result::Err(::prost::DecodeError::new("invalid enumeration value")),
+                    _ => ::core::result::Result::Err(::prost::UnknownEnumValue(value)),
                 }
             }
         }
     };
 
-    Ok(expanded.into())
+    Ok(expanded)
 }
 
 #[proc_macro_derive(Enumeration, attributes(prost))]
-pub fn enumeration(input: TokenStream) -> TokenStream {
-    try_enumeration(input).unwrap()
+pub fn enumeration(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    try_enumeration(input.into()).unwrap().into()
 }
 
 fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
-    let input: DeriveInput = syn::parse(input)?;
+    let input: DeriveInput = syn::parse2(input)?;
 
     let ident = input.ident;
 
@@ -414,31 +413,29 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
         }
     }
 
-    let mut tags = fields
+    // Oneof variants cannot be oneofs themselves, so it's impossible to have a field with multiple
+    // tags.
+    assert!(fields.iter().all(|(_, field)| field.tags().len() == 1));
+
+    if let Some(duplicate_tag) = fields
         .iter()
-        .flat_map(|&(ref variant_ident, ref field)| -> Result<u32, Error> {
-            if field.tags().len() > 1 {
-                bail!(
-                    "invalid oneof variant {}::{}: oneof variants may only have a single tag",
-                    ident,
-                    variant_ident
-                );
-            }
-            Ok(field.tags()[0])
-        })
-        .collect::<Vec<_>>();
-    tags.sort_unstable();
-    tags.dedup();
-    if tags.len() != fields.len() {
-        panic!("invalid oneof {}: variants have duplicate tags", ident);
+        .flat_map(|(_, field)| field.tags())
+        .duplicates()
+        .next()
+    {
+        bail!(
+            "invalid oneof {}: multiple variants have tag {}",
+            ident,
+            duplicate_tag
+        );
     }
 
-    let encode = fields.iter().map(|&(ref variant_ident, ref field)| {
+    let encode = fields.iter().map(|(variant_ident, field)| {
         let encode = field.encode(quote!(*value));
         quote!(#ident::#variant_ident(ref value) => { #encode })
     });
 
-    let merge = fields.iter().map(|&(ref variant_ident, ref field)| {
+    let merge = fields.iter().map(|(variant_ident, field)| {
         let tag = field.tags()[0];
         let merge = field.merge(quote!(value));
         quote! {
@@ -457,7 +454,7 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
         }
     });
 
-    let encoded_len = fields.iter().map(|&(ref variant_ident, ref field)| {
+    let encoded_len = fields.iter().map(|(variant_ident, field)| {
         let encoded_len = field.encoded_len(quote!(*value));
         quote!(#ident::#variant_ident(ref value) => #encoded_len)
     });
@@ -465,21 +462,21 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
     let expanded = quote! {
         impl #impl_generics #ident #ty_generics #where_clause {
             /// Encodes the message to a buffer.
-            pub fn encode<B>(&self, buf: &mut B) where B: ::prost::bytes::BufMut {
+            pub fn encode(&self, buf: &mut impl ::prost::bytes::BufMut) {
                 match *self {
                     #(#encode,)*
                 }
             }
 
             /// Decodes an instance of the message from a buffer, and merges it into self.
-            pub fn merge<B>(
+            pub fn merge(
                 field: &mut ::core::option::Option<#ident #ty_generics>,
                 tag: u32,
-                wire_type: ::prost::encoding::WireType,
-                buf: &mut B,
+                wire_type: ::prost::encoding::wire_type::WireType,
+                buf: &mut impl ::prost::bytes::Buf,
                 ctx: ::prost::encoding::DecodeContext,
             ) -> ::core::result::Result<(), ::prost::DecodeError>
-            where B: ::prost::bytes::Buf {
+            {
                 match tag {
                     #(#merge,)*
                     _ => unreachable!(concat!("invalid ", stringify!(#ident), " tag: {}"), tag),
@@ -499,7 +496,7 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
     let expanded = if skip_debug {
         expanded
     } else {
-        let debug = fields.iter().map(|&(ref variant_ident, ref field)| {
+        let debug = fields.iter().map(|(variant_ident, field)| {
             let wrapper = field.debug(quote!(*value));
             quote!(#ident::#variant_ident(ref value) => {
                 let wrapper = #wrapper;
@@ -521,10 +518,99 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
         }
     };
 
-    Ok(expanded.into())
+    Ok(expanded)
 }
 
 #[proc_macro_derive(Oneof, attributes(prost))]
-pub fn oneof(input: TokenStream) -> TokenStream {
-    try_oneof(input).unwrap()
+pub fn oneof(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    try_oneof(input.into()).unwrap().into()
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{try_message, try_oneof};
+    use quote::quote;
+
+    #[test]
+    fn test_rejects_colliding_message_fields() {
+        let output = try_message(quote!(
+            struct Invalid {
+                #[prost(bool, tag = "1")]
+                a: bool,
+                #[prost(oneof = "super::Whatever", tags = "4, 5, 1")]
+                b: Option<super::Whatever>,
+            }
+        ));
+        assert_eq!(
+            output
+                .expect_err("did not reject colliding message fields")
+                .to_string(),
+            "message Invalid has multiple fields with tag 1"
+        );
+    }
+
+    #[test]
+    fn test_rejects_colliding_oneof_variants() {
+        let output = try_oneof(quote!(
+            pub enum Invalid {
+                #[prost(bool, tag = "1")]
+                A(bool),
+                #[prost(bool, tag = "3")]
+                B(bool),
+                #[prost(bool, tag = "1")]
+                C(bool),
+            }
+        ));
+        assert_eq!(
+            output
+                .expect_err("did not reject colliding oneof variants")
+                .to_string(),
+            "invalid oneof Invalid: multiple variants have tag 1"
+        );
+    }
+
+    #[test]
+    fn test_rejects_multiple_tags_oneof_variant() {
+        let output = try_oneof(quote!(
+            enum What {
+                #[prost(bool, tag = "1", tag = "2")]
+                A(bool),
+            }
+        ));
+        assert_eq!(
+            output
+                .expect_err("did not reject multiple tags on oneof variant")
+                .to_string(),
+            "duplicate tag attributes: 1 and 2"
+        );
+
+        let output = try_oneof(quote!(
+            enum What {
+                #[prost(bool, tag = "3")]
+                #[prost(tag = "4")]
+                A(bool),
+            }
+        ));
+        assert!(output.is_err());
+        assert_eq!(
+            output
+                .expect_err("did not reject multiple tags on oneof variant")
+                .to_string(),
+            "duplicate tag attributes: 3 and 4"
+        );
+
+        let output = try_oneof(quote!(
+            enum What {
+                #[prost(bool, tags = "5,6")]
+                A(bool),
+            }
+        ));
+        assert!(output.is_err());
+        assert_eq!(
+            output
+                .expect_err("did not reject multiple tags on oneof variant")
+                .to_string(),
+            "unknown attribute(s): #[prost(tags = \"5,6\")]"
+        );
+    }
 }
diff --git a/third_party/rust/prost/.cargo-checksum.json b/third_party/rust/prost/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"a3ac5fec4abcd9ef35ba4cb8924964a1158c1b2c48c70f87532aacbc5d34cbb2","FUZZING.md":"90e5d9ae4cf3b975a7f917224cec20d5d757a9ca33e2bd6d3e2bb984409d3292","KANI.md":"7dd64e21f8ade66b2b795042159f1163bfd304ff58172deb126fe788d71b2056","LICENSE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","README.md":"f76f54a5eda4a38e24d360db6370dde5172c07c117ddb92878c9a613c50c7c68","benches/varint.rs":"25e28eadeb5092882281eaa16307ae72cbdabe04a308c9cfe15d3a62c8ead40b","clippy.toml":"10eea08f9e26e0dc498e431ac3a62b861bd74029d1cad8a394284af4cbc90532","flake.lock":"c0f731ad4db81f7f120a79a6dac4467970d410b9942688eb6286cd6f3e8c1f01","flake.nix":"08f0e2ffcf522caa30399f3f540dc9c2fe46c9745ce76b45563118045cd4f4d1","prepare-release.sh":"67f42e0649d33269c88272e69a9bf48d02de42126a9942ac6298b6995adea8df","publish-release.sh":"0cf0c6ec2765f19d45e271d005a6ad46f7b9b00241ba8a915ece8d100062546b","src/encoding.rs":"bcaeeecb90826f37dde6ee6c3d657ff4d69d6fe0e865e3a256665086d046400f","src/error.rs":"bfccee0fc06836f9b32b1cdb631237031d0ba8e1bc82548db3c4a6c10c06e784","src/lib.rs":"df1534418dc88712e7d77f2cce7297fd9ff520d4a56e576dfbe38700f6fa254a","src/message.rs":"e4f85ffe6f0a66778b782199e29d450ec53a10e818e20199b15bb1d11d067521","src/name.rs":"ef5ac157cfeb195de60e0d5a3de00fe6e1d864182d557032841259049f72c173","src/types.rs":"edfefaf56ab4bc12c98cbcd9d0b3ca18c10352217556c193be6314990ecffd9c"},"package":"f4fdd22f3b9c31b53c060df4a0613a1c7f062d4115a2b984dd15b1858f7e340d"}
-\ No newline at end of file
+{"files":{"Cargo.lock":"9873018da9575867e7e8656161d370bf3ed9d0b3d335491dbf0c3d4f45fe691f","Cargo.toml":"2519990bf4b36f0aa5594ae64c76503520091683f0cfda22f6c847ab06797c5a","LICENSE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","README.md":"436225c24c3e878a2bc9f2b9b2b3cc7b39073866b7a7b4faf80d3e197becdd73","benches/varint.rs":"94f8949ac90218017cbf66e5d12de10604d20bc844a988531b2a8e1c0d14affb","src/encoding.rs":"1d02e973675eca9f07c8b0244d772ba7e06273ca77c5a580af108f23ad1d5174","src/encoding/length_delimiter.rs":"70749756af605a924ccde31ce4690c0e45dff0d936aee42c5aae152d342d8b99","src/encoding/varint.rs":"3d58f41e04abea61ef797fe3337934a4521136464cf8c1e3ecf2acc7e0b5e181","src/encoding/wire_type.rs":"b41c05db9db77f952cffd2ac85bd23bb951556b9384c9160a303fdf98a7c89c5","src/error.rs":"0b081316425f4d4d9dce7c7e640a0494edfea96e5d3938ef8238c2461dc40b24","src/lib.rs":"dbefebf38d29872e9b03d5340761cb064868329439bcbd305141b272e8619344","src/message.rs":"2e365d186e9bfcc4e1c4c7174a0b16d5925758d70b61584df1548f01ddd219d4","src/name.rs":"4524233d6c1a85ca55ce54d9740e72ecbb05714b558e8a77346c0a125a2e5320","src/types.rs":"4c73041aa3ad7daad9f82ac484ae728dc6f712cc6c3da2aa6514b6428002e0d1"},"package":"2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"}
+\ No newline at end of file
diff --git a/third_party/rust/prost/Cargo.lock b/third_party/rust/prost/Cargo.lock
@@ -0,0 +1,787 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstyle"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+
+[[package]]
+name = "anyhow"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "bit-set"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb3b4b9e5a7c7514dfa52869339ee98b3156b0bfb4e8a77c4ff4babb64b1604f"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b17a95aa67cc7b5ebd32aa5370189aa0d79069ef1c64ce893bd30fb24bff20ec"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afb84c814227b90d6895e01398aee0d8033c00e7466aca416fb6a8e0eb19d8a7"
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.13.3+wasi-0.2.2",
+ "windows-targets",
+]
+
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "540654e97a3f4470a492cd30ff187bc95d89557a903a2bbf112e2fae98104ef2"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.164"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "433bfe06b8c75da9b2e3fbea6e5329ff87748f0b144ef75306e674c3f6f7c13f"
+
+[[package]]
+name = "libm"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+
+[[package]]
+name = "oorandom"
+version = "11.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy 0.7.35",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "proptest"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d"
+dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags",
+ "lazy_static",
+ "num-traits",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
+[[package]]
+name = "prost"
+version = "0.13.5"
+dependencies = [
+ "bytes",
+ "criterion",
+ "proptest",
+ "prost-derive",
+ "rand 0.9.0",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.0",
+ "zerocopy 0.8.17",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.0",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.15",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b08f3c9802962f7e1b25113931d94f43ed9725bebc59db9d0c3e9a23b67e15ff"
+dependencies = [
+ "getrandom 0.3.1",
+ "zerocopy 0.8.17",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustix"
+version = "0.38.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rusty-fork"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.215"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.215"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.133"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa91407dacce3a68c56de03abe2760159582b846c6a4acd2f456618087f12713"
+dependencies = [
+ "zerocopy-derive 0.8.17",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06718a168365cad3d5ff0bb133aad346959a2074bd4a85c121255a11304a8626"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/third_party/rust/prost/Cargo.toml b/third_party/rust/prost/Cargo.toml
@@ -11,16 +11,22 @@
 
 [package]
 edition = "2021"
-rust-version = "1.60"
+rust-version = "1.71.1"
 name = "prost"
-version = "0.12.1"
+version = "0.13.5"
 authors = [
     "Dan Burkert <dan@danburkert.com>",
-    "Lucio Franco <luciofranco14@gmail.com",
+    "Lucio Franco <luciofranco14@gmail.com>",
+    "Casper Meijn <casper@meijn.net>",
     "Tokio Contributors <team@tokio.rs>",
 ]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
 description = "A Protocol Buffers implementation for the Rust Language."
-documentation = "https://docs.rs/prost"
 readme = "README.md"
 keywords = [
     "protobuf",
@@ -30,14 +36,24 @@ categories = ["encoding"]
 license = "Apache-2.0"
 repository = "https://github.com/tokio-rs/prost"
 
-[profile.bench]
-debug = 2
+[features]
+default = [
+    "derive",
+    "std",
+]
+derive = ["dep:prost-derive"]
+no-recursion-limit = []
+prost-derive = ["derive"]
+std = []
 
 [lib]
+name = "prost"
+path = "src/lib.rs"
 bench = false
 
 [[bench]]
 name = "varint"
+path = "benches/varint.rs"
 harness = false
 
 [dependencies.bytes]
@@ -45,30 +61,15 @@ version = "1"
 default-features = false
 
 [dependencies.prost-derive]
-version = "0.12.1"
+version = "0.13.5"
 optional = true
 
 [dev-dependencies.criterion]
-version = "0.4"
-default-features = false
-
-[dev-dependencies.env_logger]
-version = "0.10"
+version = "0.5"
 default-features = false
 
-[dev-dependencies.log]
-version = "0.4"
-
 [dev-dependencies.proptest]
 version = "1"
 
 [dev-dependencies.rand]
-version = "0.8"
-
-[features]
-default = [
-    "prost-derive",
-    "std",
-]
-no-recursion-limit = []
-std = []
+version = "0.9"
diff --git a/third_party/rust/prost/FUZZING.md b/third_party/rust/prost/FUZZING.md
@@ -1,27 +0,0 @@
-# Fuzzing
-
-Prost ships a few fuzz tests, using both libfuzzer and aflfuzz.
-
-
-## afl
-
-To run the afl fuzz tests, first install cargo-afl:
-
-    cargo install -f afl
-
-Then build a fuzz target and run afl on it:
-
-    cd fuzz/afl/<target>/
-    cargo afl build --bin fuzz-target
-    cargo afl fuzz -i in -o out target/debug/fuzz-target
-
-To reproduce a crash:
-
-    cd fuzz/afl/<target>/
-    cargo build --bin reproduce
-    cargo run --bin reproduce -- out/crashes/<crashfile>
-
-
-## libfuzzer
-
-TODO
diff --git a/third_party/rust/prost/KANI.md b/third_party/rust/prost/KANI.md
@@ -1,69 +0,0 @@
-# Kani
-This document describes how to **locally** install and use Kani, along
-with its experimental PropProof feature. Because of instability in
-Kani internals, the GitHub action is the recommended option if you are
-running in CI.
-
-Kani is a software verification tool that complements testing by
-proving the absence of certain classes of bugs like unwrap exceptions,
-overflows, and assertion failures. See the [Kani
-book](https://model-checking.github.io/kani/) for a full list of
-capabilities and limitations.
-
-## Installing Kani and PropProof
--  The install instructions for Kani can be [found
-   here](https://model-checking.github.io/kani/install-guide.html). Once
-   Kani is installed, you can run with `cargo kani` for projects or
-   `kani` for individual Rust files.
-- **[UNSTABLE]** To use PropProof, first download the source code
-  from the Kani repository.
-  ```bash
-  git clone https://github.com/model-checking/kani.git --branch features/proptest propproof
-  cd propproof; git submodule update --init
-  ```
-
-  Then, use `.cargo/config.toml` enable it in the local directory you
-  want to run Kani in. This will override the `proptest` import in
-  your repo.
-
-  ```bash
-  cd $YOUR_REPO_LOCAL_PATH
-  mkdir '.cargo'
-  echo "paths =[\"$PATH_TO_PROPPROOF\"]" > .cargo/config.toml
-  ```
-
-**Please Note**:
-- `features/proptest` branch under Kani is likely not the final
-  location for this code. If these instructions stop working, please
-  consult the Kani documentation and file an issue on [the Kani
-  repo](https://github.com/model-checking/kani.git).
-- The cargo config file will force cargo to always use PropProof. To
-  use `proptest`, delete the file.
-
-## Running Kani
-After installing Kani and PropProof, `cargo kani --tests` should
-automatically run `proptest!` harnesses inside your crate. Use
-`--harness` to run a specific harness, and `-p` for a specific
-sub-crate.
-
-If Kani returns with an error, you can use the concrete playback
-feature using `--enable-unstable --concrete-playback print` and paste
-in the code to your repository. Running this harness with `cargo test`
-will replay the input found by Kani that produced this crash. Please
-note that this feature is unstable and using `--concrete-playback
-inplace` to automatically inject a replay harness is not supported
-when using PropProof.
-
-## Debugging CI Failure
-```yaml
-      - name: Verify with Kani
-        uses: model-checking/kani-github-action@v0.xx
-        with:
-          enable-propproof: true
-          args: |
-            $KANI_ARGUMENTS
-```
-
-The above GitHub CI workflow is equivalent to `cargo kani
-$KANI_ARGUMENTS` with PropProof installed. To replicate issues
-locally, run `cargo kani` with the same arguments.
diff --git a/third_party/rust/prost/README.md b/third_party/rust/prost/README.md
@@ -1,4 +1,4 @@
-![continuous integration](https://github.com/tokio-rs/prost/workflows/continuous%20integration/badge.svg)
+[![continuous integration](https://github.com/tokio-rs/prost/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/tokio-rs/prost/actions/workflows/ci.yml?query=branch%3Amaster)
 [![Documentation](https://docs.rs/prost/badge.svg)](https://docs.rs/prost/)
 [![Crate](https://img.shields.io/crates/v/prost.svg)](https://crates.io/crates/prost)
 [![Dependency Status](https://deps.rs/repo/github/tokio-rs/prost/status.svg)](https://deps.rs/repo/github/tokio-rs/prost)
@@ -30,21 +30,23 @@ First, add `prost` and its public dependencies to your `Cargo.toml`:
 
 ```ignore
 [dependencies]
-prost = "0.12"
+prost = "0.13"
 # Only necessary if using Protobuf well-known types:
-prost-types = "0.12"
+prost-types = "0.13"
 ```
 
 The recommended way to add `.proto` compilation to a Cargo project is to use the
-`prost-build` library. See the [`prost-build` documentation](prost-build) for
+`prost-build` library. See the [`prost-build` documentation][prost-build] for
 more details and examples.
 
-See the [snazzy repository](https://github.com/danburkert/snazzy) for a simple
-start-to-finish example.
+See the [snazzy repository][snazzy] for a simple start-to-finish example.
+
+[prost-build]: https://docs.rs/prost-build/latest/prost_build/
+[snazzy]: https://github.com/danburkert/snazzy
 
 ### MSRV
 
-`prost` follows the `tokio-rs` projects MSRV model and supports 1.60. For more
+`prost` follows the `tokio-rs` project's MSRV model and supports 1.70. For more
 information on the tokio msrv policy you can check it out [here][tokio msrv]
 
 [tokio msrv]: https://github.com/tokio-rs/tokio/#supported-rust-versions
@@ -59,8 +61,8 @@ possible.
 
 With `prost-build` v0.11 release, `protoc` will be required to invoke
 `compile_protos` (unless `skip_protoc` is enabled). Prost will no longer provide
-bundled a `protoc` or attempt to compile `protoc` for users. For install
-instructions for `protoc` please check out the [protobuf install] instructions.
+bundled `protoc` or attempt to compile `protoc` for users. For install
+instructions for `protoc`, please check out the [protobuf install] instructions.
 
 [protobuf install]: https://github.com/protocolbuffers/protobuf#protobuf-compiler-installation
 
@@ -378,9 +380,9 @@ the `std` features in `prost` and `prost-types`:
 
 ```ignore
 [dependencies]
-prost = { version = "0.6", default-features = false, features = ["prost-derive"] }
+prost = { version = "0.13.5", default-features = false, features = ["prost-derive"] }
 # Only necessary if using Protobuf well-known types:
-prost-types = { version = "0.6", default-features = false }
+prost-types = { version = "0.13.5", default-features = false }
 ```
 
 Additionally, configure `prost-build` to output `BTreeMap`s instead of `HashMap`s
@@ -461,6 +463,11 @@ The prost project maintains flakes support for local development. Once you have
 nix and nix flakes setup you can just run `nix develop` to get a shell
 configured with the required dependencies to compile the whole project.
 
+## Feature Flags
+- `std`: Enable integration with standard library. Disable this feature for `no_std` support. This feature is enabled by default.
+- `derive`: Enable integration with `prost-derive`. Disable this feature to reduce compile times. This feature is enabled by default.
+- `prost-derive`: Deprecated. Alias for `derive` feature.
+- `no-recursion-limit`: Disable the recursion limit. The recursion limit is 100 and cannot be customized. 
 
 ## FAQ
 
diff --git a/third_party/rust/prost/benches/varint.rs b/third_party/rust/prost/benches/varint.rs
@@ -2,7 +2,7 @@ use std::mem;
 
 use bytes::Buf;
 use criterion::{Criterion, Throughput};
-use prost::encoding::{decode_varint, encode_varint, encoded_len_varint};
+use prost::encoding::varint::{decode_varint, encode_varint, encoded_len_varint};
 use rand::{rngs::StdRng, seq::SliceRandom, SeedableRng};
 
 fn benchmark_varint(criterion: &mut Criterion, name: &str, mut values: Vec<u64>) {
diff --git a/third_party/rust/prost/clippy.toml b/third_party/rust/prost/clippy.toml
@@ -1 +0,0 @@
-too-many-arguments-threshold=8
diff --git a/third_party/rust/prost/flake.lock b/third_party/rust/prost/flake.lock
@@ -1,43 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "locked": {
-        "lastModified": 1667395993,
-        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1667969101,
-        "narHash": "sha256-GL53T705HO7Q/KVfbb5STx8AxFs8YgaGY8pvAZC+O7U=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "bbf77421ac51a7c93f5f0f760da99e4dbce614fa",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
diff --git a/third_party/rust/prost/flake.nix b/third_party/rust/prost/flake.nix
@@ -1,20 +0,0 @@
-{
-  description = "Prost dependencies";
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = import nixpkgs { inherit system; };
-      in
-      {
-        devShells.default = pkgs.mkShell {
-          packages = with pkgs; [ cargo rustc ];
-          buildInputs = with pkgs; [ pkg-config protobuf curl cmake ninja ];
-        };
-      });
-}
diff --git a/third_party/rust/prost/prepare-release.sh b/third_party/rust/prost/prepare-release.sh
@@ -1,47 +0,0 @@
-#!/bin/bash
-
-# Script which automates modifying source version fields, and creating a release
-# commit and tag. The commit and tag are not automatically pushed, nor are the
-# crates published (see publish-release.sh).
-
-set -ex
-
-if [ "$#" -ne 1 ]
-then
-  echo "Usage: $0 <version>"
-  exit 1
-fi
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-VERSION="$1"
-MINOR="$( echo ${VERSION} | cut -d\. -f1-2 )"
-
-VERSION_MATCHER="([a-z0-9\\.-]+)"
-PROST_CRATE_MATCHER="(prost|prost-[a-z]+)"
-
-# Update the README.md.
-sed -i -E "s/${PROST_CRATE_MATCHER} = \"${VERSION_MATCHER}\"/\1 = \"${MINOR}\"/" "$DIR/README.md"
-
-# Update html_root_url attributes.
-sed -i -E "s~html_root_url = \"https://docs\.rs/${PROST_CRATE_MATCHER}/$VERSION_MATCHER\"~html_root_url = \"https://docs.rs/\1/${VERSION}\"~" \
-  "$DIR/src/lib.rs" \
-  "$DIR/prost-derive/src/lib.rs" \
-  "$DIR/prost-build/src/lib.rs" \
-  "$DIR/prost-types/src/lib.rs"
-
-# Update Cargo.toml version fields.
-sed -i -E "s/^version = \"${VERSION_MATCHER}\"$/version = \"${VERSION}\"/" \
-  "$DIR/Cargo.toml" \
-  "$DIR/prost-derive/Cargo.toml" \
-  "$DIR/prost-build/Cargo.toml" \
-  "$DIR/prost-types/Cargo.toml"
-
-# Update Cargo.toml dependency versions.
-sed -i -E "s/^${PROST_CRATE_MATCHER} = \{ version = \"${VERSION_MATCHER}\"/\1 = { version = \"${VERSION}\"/" \
-  "$DIR/Cargo.toml" \
-  "$DIR/prost-derive/Cargo.toml" \
-  "$DIR/prost-build/Cargo.toml" \
-  "$DIR/prost-types/Cargo.toml"
-
-git commit -a -m "release ${VERSION}"
-git tag -a "v${VERSION}" -m "release ${VERSION}"
diff --git a/third_party/rust/prost/publish-release.sh b/third_party/rust/prost/publish-release.sh
@@ -1,33 +0,0 @@
-#!/bin/bash
-
-# Script which automates publishing a crates.io release of the prost crates.
-
-set -ex
-
-if [ "$#" -ne 0 ]
-then
-  echo "Usage: $0"
-  exit 1
-fi
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-
-CRATES=( \
-  "prost-derive" \
-  "." \
-  "prost-types" \
-  "prost-build" \
-)
-
-for CRATE in "${CRATES[@]}"; do
-  pushd "$DIR/$CRATE"
-
-  echo "Publishing $CRATE"
-
-  cargo publish
-
-  echo "Sleeping 5 seconds...for the release to be visible"
-  sleep 5
-
-  popd
-done
diff --git a/third_party/rust/prost/src/encoding.rs b/third_party/rust/prost/src/encoding.rs
@@ -8,182 +8,24 @@ use alloc::collections::BTreeMap;
 use alloc::format;
 use alloc::string::String;
 use alloc::vec::Vec;
-use core::cmp::min;
-use core::convert::TryFrom;
 use core::mem;
 use core::str;
-use core::u32;
-use core::usize;
 
 use ::bytes::{Buf, BufMut, Bytes};
 
 use crate::DecodeError;
 use crate::Message;
 
-/// Encodes an integer value into LEB128 variable length format, and writes it to the buffer.
-/// The buffer must have enough remaining space (maximum 10 bytes).
-#[inline]
-pub fn encode_varint<B>(mut value: u64, buf: &mut B)
-where
-    B: BufMut,
-{
-    loop {
-        if value < 0x80 {
-            buf.put_u8(value as u8);
-            break;
-        } else {
-            buf.put_u8(((value & 0x7F) | 0x80) as u8);
-            value >>= 7;
-        }
-    }
-}
-
-/// Decodes a LEB128-encoded variable length integer from the buffer.
-#[inline]
-pub fn decode_varint<B>(buf: &mut B) -> Result<u64, DecodeError>
-where
-    B: Buf,
-{
-    let bytes = buf.chunk();
-    let len = bytes.len();
-    if len == 0 {
-        return Err(DecodeError::new("invalid varint"));
-    }
+pub mod varint;
+pub use varint::{decode_varint, encode_varint, encoded_len_varint};
 
-    let byte = bytes[0];
-    if byte < 0x80 {
-        buf.advance(1);
-        Ok(u64::from(byte))
-    } else if len > 10 || bytes[len - 1] < 0x80 {
-        let (value, advance) = decode_varint_slice(bytes)?;
-        buf.advance(advance);
-        Ok(value)
-    } else {
-        decode_varint_slow(buf)
-    }
-}
+pub mod length_delimiter;
+pub use length_delimiter::{
+    decode_length_delimiter, encode_length_delimiter, length_delimiter_len,
+};
 
-/// Decodes a LEB128-encoded variable length integer from the slice, returning the value and the
-/// number of bytes read.
-///
-/// Based loosely on [`ReadVarint64FromArray`][1] with a varint overflow check from
-/// [`ConsumeVarint`][2].
-///
-/// ## Safety
-///
-/// The caller must ensure that `bytes` is non-empty and either `bytes.len() >= 10` or the last
-/// element in bytes is < `0x80`.
-///
-/// [1]: https://github.com/google/protobuf/blob/3.3.x/src/google/protobuf/io/coded_stream.cc#L365-L406
-/// [2]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
-#[inline]
-fn decode_varint_slice(bytes: &[u8]) -> Result<(u64, usize), DecodeError> {
-    // Fully unrolled varint decoding loop. Splitting into 32-bit pieces gives better performance.
-
-    // Use assertions to ensure memory safety, but it should always be optimized after inline.
-    assert!(!bytes.is_empty());
-    assert!(bytes.len() > 10 || bytes[bytes.len() - 1] < 0x80);
-
-    let mut b: u8 = unsafe { *bytes.get_unchecked(0) };
-    let mut part0: u32 = u32::from(b);
-    if b < 0x80 {
-        return Ok((u64::from(part0), 1));
-    };
-    part0 -= 0x80;
-    b = unsafe { *bytes.get_unchecked(1) };
-    part0 += u32::from(b) << 7;
-    if b < 0x80 {
-        return Ok((u64::from(part0), 2));
-    };
-    part0 -= 0x80 << 7;
-    b = unsafe { *bytes.get_unchecked(2) };
-    part0 += u32::from(b) << 14;
-    if b < 0x80 {
-        return Ok((u64::from(part0), 3));
-    };
-    part0 -= 0x80 << 14;
-    b = unsafe { *bytes.get_unchecked(3) };
-    part0 += u32::from(b) << 21;
-    if b < 0x80 {
-        return Ok((u64::from(part0), 4));
-    };
-    part0 -= 0x80 << 21;
-    let value = u64::from(part0);
-
-    b = unsafe { *bytes.get_unchecked(4) };
-    let mut part1: u32 = u32::from(b);
-    if b < 0x80 {
-        return Ok((value + (u64::from(part1) << 28), 5));
-    };
-    part1 -= 0x80;
-    b = unsafe { *bytes.get_unchecked(5) };
-    part1 += u32::from(b) << 7;
-    if b < 0x80 {
-        return Ok((value + (u64::from(part1) << 28), 6));
-    };
-    part1 -= 0x80 << 7;
-    b = unsafe { *bytes.get_unchecked(6) };
-    part1 += u32::from(b) << 14;
-    if b < 0x80 {
-        return Ok((value + (u64::from(part1) << 28), 7));
-    };
-    part1 -= 0x80 << 14;
-    b = unsafe { *bytes.get_unchecked(7) };
-    part1 += u32::from(b) << 21;
-    if b < 0x80 {
-        return Ok((value + (u64::from(part1) << 28), 8));
-    };
-    part1 -= 0x80 << 21;
-    let value = value + ((u64::from(part1)) << 28);
-
-    b = unsafe { *bytes.get_unchecked(8) };
-    let mut part2: u32 = u32::from(b);
-    if b < 0x80 {
-        return Ok((value + (u64::from(part2) << 56), 9));
-    };
-    part2 -= 0x80;
-    b = unsafe { *bytes.get_unchecked(9) };
-    part2 += u32::from(b) << 7;
-    // Check for u64::MAX overflow. See [`ConsumeVarint`][1] for details.
-    // [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
-    if b < 0x02 {
-        return Ok((value + (u64::from(part2) << 56), 10));
-    };
-
-    // We have overrun the maximum size of a varint (10 bytes) or the final byte caused an overflow.
-    // Assume the data is corrupt.
-    Err(DecodeError::new("invalid varint"))
-}
-
-/// Decodes a LEB128-encoded variable length integer from the buffer, advancing the buffer as
-/// necessary.
-///
-/// Contains a varint overflow check from [`ConsumeVarint`][1].
-///
-/// [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
-#[inline(never)]
-#[cold]
-fn decode_varint_slow<B>(buf: &mut B) -> Result<u64, DecodeError>
-where
-    B: Buf,
-{
-    let mut value = 0;
-    for count in 0..min(10, buf.remaining()) {
-        let byte = buf.get_u8();
-        value |= u64::from(byte & 0x7F) << (count * 7);
-        if byte <= 0x7F {
-            // Check for u64::MAX overflow. See [`ConsumeVarint`][1] for details.
-            // [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
-            if count == 9 && byte >= 0x02 {
-                return Err(DecodeError::new("invalid varint"));
-            } else {
-                return Ok(value);
-            }
-        }
-    }
-
-    Err(DecodeError::new("invalid varint"))
-}
+pub mod wire_type;
+pub use wire_type::{check_wire_type, WireType};
 
 /// Additional information passed to every decode/merge function.
 ///
@@ -255,56 +97,13 @@ impl DecodeContext {
     }
 }
 
-/// Returns the encoded length of the value in LEB128 variable length format.
-/// The returned value will be between 1 and 10, inclusive.
-#[inline]
-pub fn encoded_len_varint(value: u64) -> usize {
-    // Based on [VarintSize64][1].
-    // [1]: https://github.com/google/protobuf/blob/3.3.x/src/google/protobuf/io/coded_stream.h#L1301-L1309
-    ((((value | 1).leading_zeros() ^ 63) * 9 + 73) / 64) as usize
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(u8)]
-pub enum WireType {
-    Varint = 0,
-    SixtyFourBit = 1,
-    LengthDelimited = 2,
-    StartGroup = 3,
-    EndGroup = 4,
-    ThirtyTwoBit = 5,
-}
-
 pub const MIN_TAG: u32 = 1;
 pub const MAX_TAG: u32 = (1 << 29) - 1;
 
-impl TryFrom<u64> for WireType {
-    type Error = DecodeError;
-
-    #[inline]
-    fn try_from(value: u64) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(WireType::Varint),
-            1 => Ok(WireType::SixtyFourBit),
-            2 => Ok(WireType::LengthDelimited),
-            3 => Ok(WireType::StartGroup),
-            4 => Ok(WireType::EndGroup),
-            5 => Ok(WireType::ThirtyTwoBit),
-            _ => Err(DecodeError::new(format!(
-                "invalid wire type value: {}",
-                value
-            ))),
-        }
-    }
-}
-
 /// Encodes a Protobuf field key, which consists of a wire type designator and
 /// the field tag.
 #[inline]
-pub fn encode_key<B>(tag: u32, wire_type: WireType, buf: &mut B)
-where
-    B: BufMut,
-{
+pub fn encode_key(tag: u32, wire_type: WireType, buf: &mut impl BufMut) {
     debug_assert!((MIN_TAG..=MAX_TAG).contains(&tag));
     let key = (tag << 3) | wire_type as u32;
     encode_varint(u64::from(key), buf);
@@ -313,10 +112,7 @@ where
 /// Decodes a Protobuf field key, which consists of a wire type designator and
 /// the field tag.
 #[inline(always)]
-pub fn decode_key<B>(buf: &mut B) -> Result<(u32, WireType), DecodeError>
-where
-    B: Buf,
-{
+pub fn decode_key(buf: &mut impl Buf) -> Result<(u32, WireType), DecodeError> {
     let key = decode_varint(buf)?;
     if key > u64::from(u32::MAX) {
         return Err(DecodeError::new(format!("invalid key value: {}", key)));
@@ -334,21 +130,8 @@ where
 /// Returns the width of an encoded Protobuf field key with the given tag.
 /// The returned width will be between 1 and 5 bytes (inclusive).
 #[inline]
-pub fn key_len(tag: u32) -> usize {
-    encoded_len_varint(u64::from(tag << 3))
-}
-
-/// Checks that the expected wire type matches the actual wire type,
-/// or returns an error result.
-#[inline]
-pub fn check_wire_type(expected: WireType, actual: WireType) -> Result<(), DecodeError> {
-    if expected != actual {
-        return Err(DecodeError::new(format!(
-            "invalid wire type: {:?} (expected {:?})",
-            actual, expected
-        )));
-    }
-    Ok(())
+pub const fn key_len(tag: u32) -> usize {
+    encoded_len_varint((tag << 3) as u64)
 }
 
 /// Helper function which abstracts reading a length delimiter prefix followed
@@ -380,15 +163,12 @@ where
     Ok(())
 }
 
-pub fn skip_field<B>(
+pub fn skip_field(
     wire_type: WireType,
     tag: u32,
-    buf: &mut B,
+    buf: &mut impl Buf,
     ctx: DecodeContext,
-) -> Result<(), DecodeError>
-where
-    B: Buf,
-{
+) -> Result<(), DecodeError> {
     ctx.limit_reached()?;
     let len = match wire_type {
         WireType::Varint => decode_varint(buf).map(|_| 0)?,
@@ -421,10 +201,7 @@ where
 /// Helper macro which emits an `encode_repeated` function for the type.
 macro_rules! encode_repeated {
     ($ty:ty) => {
-        pub fn encode_repeated<B>(tag: u32, values: &[$ty], buf: &mut B)
-        where
-            B: BufMut,
-        {
+        pub fn encode_repeated(tag: u32, values: &[$ty], buf: &mut impl BufMut) {
             for value in values {
                 encode(tag, value, buf);
             }
@@ -438,15 +215,12 @@ macro_rules! merge_repeated_numeric {
      $wire_type:expr,
      $merge:ident,
      $merge_repeated:ident) => {
-        pub fn $merge_repeated<B>(
+        pub fn $merge_repeated(
             wire_type: WireType,
             values: &mut Vec<$ty>,
-            buf: &mut B,
+            buf: &mut impl Buf,
             ctx: DecodeContext,
-        ) -> Result<(), DecodeError>
-        where
-            B: Buf,
-        {
+        ) -> Result<(), DecodeError> {
             if wire_type == WireType::LengthDelimited {
                 // Packed.
                 merge_loop(values, buf, ctx, |values, buf, ctx| {
@@ -486,12 +260,12 @@ macro_rules! varint {
          pub mod $proto_ty {
             use crate::encoding::*;
 
-            pub fn encode<B>(tag: u32, $to_uint64_value: &$ty, buf: &mut B) where B: BufMut {
+            pub fn encode(tag: u32, $to_uint64_value: &$ty, buf: &mut impl BufMut) {
                 encode_key(tag, WireType::Varint, buf);
                 encode_varint($to_uint64, buf);
             }
 
-            pub fn merge<B>(wire_type: WireType, value: &mut $ty, buf: &mut B, _ctx: DecodeContext) -> Result<(), DecodeError> where B: Buf {
+            pub fn merge(wire_type: WireType, value: &mut $ty, buf: &mut impl Buf, _ctx: DecodeContext) -> Result<(), DecodeError> {
                 check_wire_type(WireType::Varint, wire_type)?;
                 let $from_uint64_value = decode_varint(buf)?;
                 *value = $from_uint64;
@@ -500,7 +274,7 @@ macro_rules! varint {
 
             encode_repeated!($ty);
 
-            pub fn encode_packed<B>(tag: u32, values: &[$ty], buf: &mut B) where B: BufMut {
+            pub fn encode_packed(tag: u32, values: &[$ty], buf: &mut impl BufMut) {
                 if values.is_empty() { return; }
 
                 encode_key(tag, WireType::LengthDelimited, buf);
@@ -609,23 +383,17 @@ macro_rules! fixed_width {
         pub mod $proto_ty {
             use crate::encoding::*;
 
-            pub fn encode<B>(tag: u32, value: &$ty, buf: &mut B)
-            where
-                B: BufMut,
-            {
+            pub fn encode(tag: u32, value: &$ty, buf: &mut impl BufMut) {
                 encode_key(tag, $wire_type, buf);
                 buf.$put(*value);
             }
 
-            pub fn merge<B>(
+            pub fn merge(
                 wire_type: WireType,
                 value: &mut $ty,
-                buf: &mut B,
+                buf: &mut impl Buf,
                 _ctx: DecodeContext,
-            ) -> Result<(), DecodeError>
-            where
-                B: Buf,
-            {
+            ) -> Result<(), DecodeError> {
                 check_wire_type($wire_type, wire_type)?;
                 if buf.remaining() < $width {
                     return Err(DecodeError::new("buffer underflow"));
@@ -636,10 +404,7 @@ macro_rules! fixed_width {
 
             encode_repeated!($ty);
 
-            pub fn encode_packed<B>(tag: u32, values: &[$ty], buf: &mut B)
-            where
-                B: BufMut,
-            {
+            pub fn encode_packed(tag: u32, values: &[$ty], buf: &mut impl BufMut) {
                 if values.is_empty() {
                     return;
                 }
@@ -759,15 +524,12 @@ macro_rules! length_delimited {
     ($ty:ty) => {
         encode_repeated!($ty);
 
-        pub fn merge_repeated<B>(
+        pub fn merge_repeated(
             wire_type: WireType,
             values: &mut Vec<$ty>,
-            buf: &mut B,
+            buf: &mut impl Buf,
             ctx: DecodeContext,
-        ) -> Result<(), DecodeError>
-        where
-            B: Buf,
-        {
+        ) -> Result<(), DecodeError> {
             check_wire_type(WireType::LengthDelimited, wire_type)?;
             let mut value = Default::default();
             merge(wire_type, &mut value, buf, ctx)?;
@@ -794,23 +556,18 @@ macro_rules! length_delimited {
 pub mod string {
     use super::*;
 
-    pub fn encode<B>(tag: u32, value: &String, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    pub fn encode(tag: u32, value: &String, buf: &mut impl BufMut) {
         encode_key(tag, WireType::LengthDelimited, buf);
         encode_varint(value.len() as u64, buf);
         buf.put_slice(value.as_bytes());
     }
-    pub fn merge<B>(
+
+    pub fn merge(
         wire_type: WireType,
         value: &mut String,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         // ## Unsafety
         //
         // `string::merge` reuses `bytes::merge`, with an additional check of utf-8
@@ -826,7 +583,7 @@ pub mod string {
         // in the buf implementation, a drop guard is used.
         unsafe {
             struct DropGuard<'a>(&'a mut Vec<u8>);
-            impl<'a> Drop for DropGuard<'a> {
+            impl Drop for DropGuard<'_> {
                 #[inline]
                 fn drop(&mut self) {
                     self.0.clear();
@@ -882,14 +639,10 @@ mod sealed {
         fn len(&self) -> usize;
 
         /// Replace contents of this buffer with the contents of another buffer.
-        fn replace_with<B>(&mut self, buf: B)
-        where
-            B: Buf;
+        fn replace_with(&mut self, buf: impl Buf);
 
         /// Appends this buffer to the (contents of) other buffer.
-        fn append_to<B>(&self, buf: &mut B)
-        where
-            B: BufMut;
+        fn append_to(&self, buf: &mut impl BufMut);
 
         fn is_empty(&self) -> bool {
             self.len() == 0
@@ -904,17 +657,11 @@ impl sealed::BytesAdapter for Bytes {
         Buf::remaining(self)
     }
 
-    fn replace_with<B>(&mut self, mut buf: B)
-    where
-        B: Buf,
-    {
+    fn replace_with(&mut self, mut buf: impl Buf) {
         *self = buf.copy_to_bytes(buf.remaining());
     }
 
-    fn append_to<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn append_to(&self, buf: &mut impl BufMut) {
         buf.put(self.clone())
     }
 }
@@ -926,19 +673,13 @@ impl sealed::BytesAdapter for Vec<u8> {
         Vec::len(self)
     }
 
-    fn replace_with<B>(&mut self, buf: B)
-    where
-        B: Buf,
-    {
+    fn replace_with(&mut self, buf: impl Buf) {
         self.clear();
         self.reserve(buf.remaining());
         self.put(buf);
     }
 
-    fn append_to<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn append_to(&self, buf: &mut impl BufMut) {
         buf.put(self.as_slice())
     }
 }
@@ -946,26 +687,18 @@ impl sealed::BytesAdapter for Vec<u8> {
 pub mod bytes {
     use super::*;
 
-    pub fn encode<A, B>(tag: u32, value: &A, buf: &mut B)
-    where
-        A: BytesAdapter,
-        B: BufMut,
-    {
+    pub fn encode(tag: u32, value: &impl BytesAdapter, buf: &mut impl BufMut) {
         encode_key(tag, WireType::LengthDelimited, buf);
         encode_varint(value.len() as u64, buf);
         value.append_to(buf);
     }
 
-    pub fn merge<A, B>(
+    pub fn merge(
         wire_type: WireType,
-        value: &mut A,
-        buf: &mut B,
+        value: &mut impl BytesAdapter,
+        buf: &mut impl Buf,
         _ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        A: BytesAdapter,
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         check_wire_type(WireType::LengthDelimited, wire_type)?;
         let len = decode_varint(buf)?;
         if len > buf.remaining() as u64 {
@@ -989,16 +722,12 @@ pub mod bytes {
         Ok(())
     }
 
-    pub(super) fn merge_one_copy<A, B>(
+    pub(super) fn merge_one_copy(
         wire_type: WireType,
-        value: &mut A,
-        buf: &mut B,
+        value: &mut impl BytesAdapter,
+        buf: &mut impl Buf,
         _ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        A: BytesAdapter,
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         check_wire_type(WireType::LengthDelimited, wire_type)?;
         let len = decode_varint(buf)?;
         if len > buf.remaining() as u64 {
@@ -1055,10 +784,9 @@ pub mod bytes {
 pub mod message {
     use super::*;
 
-    pub fn encode<M, B>(tag: u32, msg: &M, buf: &mut B)
+    pub fn encode<M>(tag: u32, msg: &M, buf: &mut impl BufMut)
     where
         M: Message,
-        B: BufMut,
     {
         encode_key(tag, WireType::LengthDelimited, buf);
         encode_varint(msg.encoded_len() as u64, buf);
@@ -1088,25 +816,23 @@ pub mod message {
         )
     }
 
-    pub fn encode_repeated<M, B>(tag: u32, messages: &[M], buf: &mut B)
+    pub fn encode_repeated<M>(tag: u32, messages: &[M], buf: &mut impl BufMut)
     where
         M: Message,
-        B: BufMut,
     {
         for msg in messages {
             encode(tag, msg, buf);
         }
     }
 
-    pub fn merge_repeated<M, B>(
+    pub fn merge_repeated<M>(
         wire_type: WireType,
         messages: &mut Vec<M>,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
     ) -> Result<(), DecodeError>
     where
         M: Message + Default,
-        B: Buf,
     {
         check_wire_type(WireType::LengthDelimited, wire_type)?;
         let mut msg = M::default();
@@ -1141,26 +867,24 @@ pub mod message {
 pub mod group {
     use super::*;
 
-    pub fn encode<M, B>(tag: u32, msg: &M, buf: &mut B)
+    pub fn encode<M>(tag: u32, msg: &M, buf: &mut impl BufMut)
     where
         M: Message,
-        B: BufMut,
     {
         encode_key(tag, WireType::StartGroup, buf);
         msg.encode_raw(buf);
         encode_key(tag, WireType::EndGroup, buf);
     }
 
-    pub fn merge<M, B>(
+    pub fn merge<M>(
         tag: u32,
         wire_type: WireType,
         msg: &mut M,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
     ) -> Result<(), DecodeError>
     where
         M: Message,
-        B: Buf,
     {
         check_wire_type(WireType::StartGroup, wire_type)?;
 
@@ -1178,26 +902,24 @@ pub mod group {
         }
     }
 
-    pub fn encode_repeated<M, B>(tag: u32, messages: &[M], buf: &mut B)
+    pub fn encode_repeated<M>(tag: u32, messages: &[M], buf: &mut impl BufMut)
     where
         M: Message,
-        B: BufMut,
     {
         for msg in messages {
             encode(tag, msg, buf);
         }
     }
 
-    pub fn merge_repeated<M, B>(
+    pub fn merge_repeated<M>(
         tag: u32,
         wire_type: WireType,
         messages: &mut Vec<M>,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
     ) -> Result<(), DecodeError>
     where
         M: Message + Default,
-        B: Buf,
     {
         check_wire_type(WireType::StartGroup, wire_type)?;
         let mut msg = M::default();
@@ -1422,15 +1144,15 @@ pub mod btree_map {
 
 #[cfg(test)]
 mod test {
+    #[cfg(not(feature = "std"))]
     use alloc::string::ToString;
     use core::borrow::Borrow;
     use core::fmt::Debug;
-    use core::u64;
 
-    use ::bytes::{Bytes, BytesMut};
+    use ::bytes::BytesMut;
     use proptest::{prelude::*, test_runner::TestCaseResult};
 
-    use crate::encoding::*;
+    use super::*;
 
     pub fn check_type<T, B>(
         value: T,
@@ -1600,94 +1322,6 @@ mod test {
         assert!(s.is_empty());
     }
 
-    #[test]
-    fn varint() {
-        fn check(value: u64, mut encoded: &[u8]) {
-            // Small buffer.
-            let mut buf = Vec::with_capacity(1);
-            encode_varint(value, &mut buf);
-            assert_eq!(buf, encoded);
-
-            // Large buffer.
-            let mut buf = Vec::with_capacity(100);
-            encode_varint(value, &mut buf);
-            assert_eq!(buf, encoded);
-
-            assert_eq!(encoded_len_varint(value), encoded.len());
-
-            let roundtrip_value =
-                decode_varint(&mut <&[u8]>::clone(&encoded)).expect("decoding failed");
-            assert_eq!(value, roundtrip_value);
-
-            let roundtrip_value = decode_varint_slow(&mut encoded).expect("slow decoding failed");
-            assert_eq!(value, roundtrip_value);
-        }
-
-        check(2u64.pow(0) - 1, &[0x00]);
-        check(2u64.pow(0), &[0x01]);
-
-        check(2u64.pow(7) - 1, &[0x7F]);
-        check(2u64.pow(7), &[0x80, 0x01]);
-        check(300, &[0xAC, 0x02]);
-
-        check(2u64.pow(14) - 1, &[0xFF, 0x7F]);
-        check(2u64.pow(14), &[0x80, 0x80, 0x01]);
-
-        check(2u64.pow(21) - 1, &[0xFF, 0xFF, 0x7F]);
-        check(2u64.pow(21), &[0x80, 0x80, 0x80, 0x01]);
-
-        check(2u64.pow(28) - 1, &[0xFF, 0xFF, 0xFF, 0x7F]);
-        check(2u64.pow(28), &[0x80, 0x80, 0x80, 0x80, 0x01]);
-
-        check(2u64.pow(35) - 1, &[0xFF, 0xFF, 0xFF, 0xFF, 0x7F]);
-        check(2u64.pow(35), &[0x80, 0x80, 0x80, 0x80, 0x80, 0x01]);
-
-        check(2u64.pow(42) - 1, &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F]);
-        check(2u64.pow(42), &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01]);
-
-        check(
-            2u64.pow(49) - 1,
-            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F],
-        );
-        check(
-            2u64.pow(49),
-            &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01],
-        );
-
-        check(
-            2u64.pow(56) - 1,
-            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F],
-        );
-        check(
-            2u64.pow(56),
-            &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01],
-        );
-
-        check(
-            2u64.pow(63) - 1,
-            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F],
-        );
-        check(
-            2u64.pow(63),
-            &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01],
-        );
-
-        check(
-            u64::MAX,
-            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01],
-        );
-    }
-
-    #[test]
-    fn varint_overflow() {
-        let mut u64_max_plus_one: &[u8] =
-            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x02];
-
-        decode_varint(&mut u64_max_plus_one).expect_err("decoding u64::MAX + 1 succeeded");
-        decode_varint_slow(&mut u64_max_plus_one)
-            .expect_err("slow decoding u64::MAX + 1 succeeded");
-    }
-
     /// This big bowl o' macro soup generates an encoding property test for each combination of map
     /// type, scalar map key, and value type.
     /// TODO: these tests take a long time to compile, can this be improved?
diff --git a/third_party/rust/prost/src/encoding/length_delimiter.rs b/third_party/rust/prost/src/encoding/length_delimiter.rs
@@ -0,0 +1,53 @@
+pub use crate::error::{DecodeError, EncodeError, UnknownEnumValue};
+pub use crate::message::Message;
+pub use crate::name::Name;
+
+use bytes::{Buf, BufMut};
+
+use crate::encoding::varint::{decode_varint, encode_varint, encoded_len_varint};
+
+/// Encodes a length delimiter to the buffer.
+///
+/// See [Message.encode_length_delimited] for more info.
+///
+/// An error will be returned if the buffer does not have sufficient capacity to encode the
+/// delimiter.
+pub fn encode_length_delimiter(length: usize, buf: &mut impl BufMut) -> Result<(), EncodeError> {
+    let length = length as u64;
+    let required = encoded_len_varint(length);
+    let remaining = buf.remaining_mut();
+    if required > remaining {
+        return Err(EncodeError::new(required, remaining));
+    }
+    encode_varint(length, buf);
+    Ok(())
+}
+
+/// Returns the encoded length of a length delimiter.
+///
+/// Applications may use this method to ensure sufficient buffer capacity before calling
+/// `encode_length_delimiter`. The returned size will be between 1 and 10, inclusive.
+pub fn length_delimiter_len(length: usize) -> usize {
+    encoded_len_varint(length as u64)
+}
+
+/// Decodes a length delimiter from the buffer.
+///
+/// This method allows the length delimiter to be decoded independently of the message, when the
+/// message is encoded with [Message.encode_length_delimited].
+///
+/// An error may be returned in two cases:
+///
+///  * If the supplied buffer contains fewer than 10 bytes, then an error indicates that more
+///    input is required to decode the full delimiter.
+///  * If the supplied buffer contains 10 bytes or more, then the buffer contains an invalid
+///    delimiter, and typically the buffer should be considered corrupt.
+pub fn decode_length_delimiter(mut buf: impl Buf) -> Result<usize, DecodeError> {
+    let length = decode_varint(&mut buf)?;
+    if length > usize::MAX as u64 {
+        return Err(DecodeError::new(
+            "length delimiter exceeds maximum usize value",
+        ));
+    }
+    Ok(length as usize)
+}
diff --git a/third_party/rust/prost/src/encoding/varint.rs b/third_party/rust/prost/src/encoding/varint.rs
@@ -0,0 +1,274 @@
+use core::cmp::min;
+use core::num::NonZeroU64;
+
+use ::bytes::{Buf, BufMut};
+
+use crate::DecodeError;
+
+/// Encodes an integer value into LEB128 variable length format, and writes it to the buffer.
+/// The buffer must have enough remaining space (maximum 10 bytes).
+#[inline]
+pub fn encode_varint(mut value: u64, buf: &mut impl BufMut) {
+    // Varints are never more than 10 bytes
+    for _ in 0..10 {
+        if value < 0x80 {
+            buf.put_u8(value as u8);
+            break;
+        } else {
+            buf.put_u8(((value & 0x7F) | 0x80) as u8);
+            value >>= 7;
+        }
+    }
+}
+
+/// Returns the encoded length of the value in LEB128 variable length format.
+/// The returned value will be between 1 and 10, inclusive.
+#[inline]
+pub const fn encoded_len_varint(value: u64) -> usize {
+    // Based on [VarintSize64][1].
+    // [1]: https://github.com/protocolbuffers/protobuf/blob/v28.3/src/google/protobuf/io/coded_stream.h#L1744-L1756
+    // Safety: value | 1 is non-zero.
+    let log2value = unsafe { NonZeroU64::new_unchecked(value | 1) }.ilog2();
+    ((log2value * 9 + (64 + 9)) / 64) as usize
+}
+
+/// Decodes a LEB128-encoded variable length integer from the buffer.
+#[inline]
+pub fn decode_varint(buf: &mut impl Buf) -> Result<u64, DecodeError> {
+    let bytes = buf.chunk();
+    let len = bytes.len();
+    if len == 0 {
+        return Err(DecodeError::new("invalid varint"));
+    }
+
+    let byte = bytes[0];
+    if byte < 0x80 {
+        buf.advance(1);
+        Ok(u64::from(byte))
+    } else if len > 10 || bytes[len - 1] < 0x80 {
+        let (value, advance) = decode_varint_slice(bytes)?;
+        buf.advance(advance);
+        Ok(value)
+    } else {
+        decode_varint_slow(buf)
+    }
+}
+
+/// Decodes a LEB128-encoded variable length integer from the slice, returning the value and the
+/// number of bytes read.
+///
+/// Based loosely on [`ReadVarint64FromArray`][1] with a varint overflow check from
+/// [`ConsumeVarint`][2].
+///
+/// ## Safety
+///
+/// The caller must ensure that `bytes` is non-empty and either `bytes.len() >= 10` or the last
+/// element in bytes is < `0x80`.
+///
+/// [1]: https://github.com/google/protobuf/blob/3.3.x/src/google/protobuf/io/coded_stream.cc#L365-L406
+/// [2]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
+#[inline]
+fn decode_varint_slice(bytes: &[u8]) -> Result<(u64, usize), DecodeError> {
+    // Fully unrolled varint decoding loop. Splitting into 32-bit pieces gives better performance.
+
+    // Use assertions to ensure memory safety, but it should always be optimized after inline.
+    assert!(!bytes.is_empty());
+    assert!(bytes.len() > 10 || bytes[bytes.len() - 1] < 0x80);
+
+    let mut b: u8 = unsafe { *bytes.get_unchecked(0) };
+    let mut part0: u32 = u32::from(b);
+    if b < 0x80 {
+        return Ok((u64::from(part0), 1));
+    };
+    part0 -= 0x80;
+    b = unsafe { *bytes.get_unchecked(1) };
+    part0 += u32::from(b) << 7;
+    if b < 0x80 {
+        return Ok((u64::from(part0), 2));
+    };
+    part0 -= 0x80 << 7;
+    b = unsafe { *bytes.get_unchecked(2) };
+    part0 += u32::from(b) << 14;
+    if b < 0x80 {
+        return Ok((u64::from(part0), 3));
+    };
+    part0 -= 0x80 << 14;
+    b = unsafe { *bytes.get_unchecked(3) };
+    part0 += u32::from(b) << 21;
+    if b < 0x80 {
+        return Ok((u64::from(part0), 4));
+    };
+    part0 -= 0x80 << 21;
+    let value = u64::from(part0);
+
+    b = unsafe { *bytes.get_unchecked(4) };
+    let mut part1: u32 = u32::from(b);
+    if b < 0x80 {
+        return Ok((value + (u64::from(part1) << 28), 5));
+    };
+    part1 -= 0x80;
+    b = unsafe { *bytes.get_unchecked(5) };
+    part1 += u32::from(b) << 7;
+    if b < 0x80 {
+        return Ok((value + (u64::from(part1) << 28), 6));
+    };
+    part1 -= 0x80 << 7;
+    b = unsafe { *bytes.get_unchecked(6) };
+    part1 += u32::from(b) << 14;
+    if b < 0x80 {
+        return Ok((value + (u64::from(part1) << 28), 7));
+    };
+    part1 -= 0x80 << 14;
+    b = unsafe { *bytes.get_unchecked(7) };
+    part1 += u32::from(b) << 21;
+    if b < 0x80 {
+        return Ok((value + (u64::from(part1) << 28), 8));
+    };
+    part1 -= 0x80 << 21;
+    let value = value + ((u64::from(part1)) << 28);
+
+    b = unsafe { *bytes.get_unchecked(8) };
+    let mut part2: u32 = u32::from(b);
+    if b < 0x80 {
+        return Ok((value + (u64::from(part2) << 56), 9));
+    };
+    part2 -= 0x80;
+    b = unsafe { *bytes.get_unchecked(9) };
+    part2 += u32::from(b) << 7;
+    // Check for u64::MAX overflow. See [`ConsumeVarint`][1] for details.
+    // [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
+    if b < 0x02 {
+        return Ok((value + (u64::from(part2) << 56), 10));
+    };
+
+    // We have overrun the maximum size of a varint (10 bytes) or the final byte caused an overflow.
+    // Assume the data is corrupt.
+    Err(DecodeError::new("invalid varint"))
+}
+
+/// Decodes a LEB128-encoded variable length integer from the buffer, advancing the buffer as
+/// necessary.
+///
+/// Contains a varint overflow check from [`ConsumeVarint`][1].
+///
+/// [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
+#[inline(never)]
+#[cold]
+fn decode_varint_slow(buf: &mut impl Buf) -> Result<u64, DecodeError> {
+    let mut value = 0;
+    for count in 0..min(10, buf.remaining()) {
+        let byte = buf.get_u8();
+        value |= u64::from(byte & 0x7F) << (count * 7);
+        if byte <= 0x7F {
+            // Check for u64::MAX overflow. See [`ConsumeVarint`][1] for details.
+            // [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
+            if count == 9 && byte >= 0x02 {
+                return Err(DecodeError::new("invalid varint"));
+            } else {
+                return Ok(value);
+            }
+        }
+    }
+
+    Err(DecodeError::new("invalid varint"))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn varint() {
+        fn check(value: u64, encoded: &[u8]) {
+            // Small buffer.
+            let mut buf = Vec::with_capacity(1);
+            encode_varint(value, &mut buf);
+            assert_eq!(buf, encoded);
+
+            // Large buffer.
+            let mut buf = Vec::with_capacity(100);
+            encode_varint(value, &mut buf);
+            assert_eq!(buf, encoded);
+
+            assert_eq!(encoded_len_varint(value), encoded.len());
+
+            // See: https://github.com/tokio-rs/prost/pull/1008 for copying reasoning.
+            let mut encoded_copy = encoded;
+            let roundtrip_value = decode_varint(&mut encoded_copy).expect("decoding failed");
+            assert_eq!(value, roundtrip_value);
+
+            let mut encoded_copy = encoded;
+            let roundtrip_value =
+                decode_varint_slow(&mut encoded_copy).expect("slow decoding failed");
+            assert_eq!(value, roundtrip_value);
+        }
+
+        check(2u64.pow(0) - 1, &[0x00]);
+        check(2u64.pow(0), &[0x01]);
+
+        check(2u64.pow(7) - 1, &[0x7F]);
+        check(2u64.pow(7), &[0x80, 0x01]);
+        check(300, &[0xAC, 0x02]);
+
+        check(2u64.pow(14) - 1, &[0xFF, 0x7F]);
+        check(2u64.pow(14), &[0x80, 0x80, 0x01]);
+
+        check(2u64.pow(21) - 1, &[0xFF, 0xFF, 0x7F]);
+        check(2u64.pow(21), &[0x80, 0x80, 0x80, 0x01]);
+
+        check(2u64.pow(28) - 1, &[0xFF, 0xFF, 0xFF, 0x7F]);
+        check(2u64.pow(28), &[0x80, 0x80, 0x80, 0x80, 0x01]);
+
+        check(2u64.pow(35) - 1, &[0xFF, 0xFF, 0xFF, 0xFF, 0x7F]);
+        check(2u64.pow(35), &[0x80, 0x80, 0x80, 0x80, 0x80, 0x01]);
+
+        check(2u64.pow(42) - 1, &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F]);
+        check(2u64.pow(42), &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01]);
+
+        check(
+            2u64.pow(49) - 1,
+            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F],
+        );
+        check(
+            2u64.pow(49),
+            &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01],
+        );
+
+        check(
+            2u64.pow(56) - 1,
+            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F],
+        );
+        check(
+            2u64.pow(56),
+            &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01],
+        );
+
+        check(
+            2u64.pow(63) - 1,
+            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F],
+        );
+        check(
+            2u64.pow(63),
+            &[0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01],
+        );
+
+        check(
+            u64::MAX,
+            &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01],
+        );
+    }
+
+    const U64_MAX_PLUS_ONE: &[u8] = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x02];
+
+    #[test]
+    fn varint_overflow() {
+        let mut copy = U64_MAX_PLUS_ONE;
+        decode_varint(&mut copy).expect_err("decoding u64::MAX + 1 succeeded");
+    }
+
+    #[test]
+    fn variant_slow_overflow() {
+        let mut copy = U64_MAX_PLUS_ONE;
+        decode_varint_slow(&mut copy).expect_err("slow decoding u64::MAX + 1 succeeded");
+    }
+}
diff --git a/third_party/rust/prost/src/encoding/wire_type.rs b/third_party/rust/prost/src/encoding/wire_type.rs
@@ -0,0 +1,49 @@
+use crate::DecodeError;
+use alloc::format;
+
+/// Represent the wire type for protobuf encoding.
+///
+/// The integer value is equvilant with the encoded value.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u8)]
+pub enum WireType {
+    Varint = 0,
+    SixtyFourBit = 1,
+    LengthDelimited = 2,
+    StartGroup = 3,
+    EndGroup = 4,
+    ThirtyTwoBit = 5,
+}
+
+impl TryFrom<u64> for WireType {
+    type Error = DecodeError;
+
+    #[inline]
+    fn try_from(value: u64) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(WireType::Varint),
+            1 => Ok(WireType::SixtyFourBit),
+            2 => Ok(WireType::LengthDelimited),
+            3 => Ok(WireType::StartGroup),
+            4 => Ok(WireType::EndGroup),
+            5 => Ok(WireType::ThirtyTwoBit),
+            _ => Err(DecodeError::new(format!(
+                "invalid wire type value: {}",
+                value
+            ))),
+        }
+    }
+}
+
+/// Checks that the expected wire type matches the actual wire type,
+/// or returns an error result.
+#[inline]
+pub fn check_wire_type(expected: WireType, actual: WireType) -> Result<(), DecodeError> {
+    if expected != actual {
+        return Err(DecodeError::new(format!(
+            "invalid wire type: {:?} (expected {:?})",
+            actual, expected
+        )));
+    }
+    Ok(())
+}
diff --git a/third_party/rust/prost/src/error.rs b/third_party/rust/prost/src/error.rs
@@ -1,7 +1,9 @@
 //! Protobuf encoding and decoding errors.
 
 use alloc::borrow::Cow;
+#[cfg(not(feature = "std"))]
 use alloc::boxed::Box;
+#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 use core::fmt;
@@ -129,3 +131,50 @@ impl From<EncodeError> for std::io::Error {
         std::io::Error::new(std::io::ErrorKind::InvalidInput, error)
     }
 }
+
+/// An error indicating that an unknown enumeration value was encountered.
+///
+/// The Protobuf spec mandates that enumeration value sets are ‘open’, so this
+/// error's value represents an integer value unrecognized by the
+/// presently used enum definition.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct UnknownEnumValue(pub i32);
+
+impl fmt::Display for UnknownEnumValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "unknown enumeration value {}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnknownEnumValue {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_push() {
+        let mut decode_error = DecodeError::new("something failed");
+        decode_error.push("Foo bad", "bar.foo");
+        decode_error.push("Baz bad", "bar.baz");
+
+        assert_eq!(
+            decode_error.to_string(),
+            "failed to decode Protobuf message: Foo bad.bar.foo: Baz bad.bar.baz: something failed"
+        );
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn test_into_std_io_error() {
+        let decode_error = DecodeError::new("something failed");
+        let std_io_error = std::io::Error::from(decode_error);
+
+        assert_eq!(std_io_error.kind(), std::io::ErrorKind::InvalidData);
+        assert_eq!(
+            std_io_error.to_string(),
+            "failed to decode Protobuf message: something failed"
+        );
+    }
+}
diff --git a/third_party/rust/prost/src/lib.rs b/third_party/rust/prost/src/lib.rs
@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/prost/0.12.1")]
+#![doc(html_root_url = "https://docs.rs/prost/0.13.5")]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![doc = include_str!("../README.md")]
 
@@ -17,79 +17,26 @@ mod types;
 #[doc(hidden)]
 pub mod encoding;
 
-pub use crate::error::{DecodeError, EncodeError};
+pub use crate::encoding::length_delimiter::{
+    decode_length_delimiter, encode_length_delimiter, length_delimiter_len,
+};
+pub use crate::error::{DecodeError, EncodeError, UnknownEnumValue};
 pub use crate::message::Message;
 pub use crate::name::Name;
 
-use bytes::{Buf, BufMut};
-
-use crate::encoding::{decode_varint, encode_varint, encoded_len_varint};
-
 // See `encoding::DecodeContext` for more info.
 // 100 is the default recursion limit in the C++ implementation.
 #[cfg(not(feature = "no-recursion-limit"))]
 const RECURSION_LIMIT: u32 = 100;
 
-/// Encodes a length delimiter to the buffer.
-///
-/// See [Message.encode_length_delimited] for more info.
-///
-/// An error will be returned if the buffer does not have sufficient capacity to encode the
-/// delimiter.
-pub fn encode_length_delimiter<B>(length: usize, buf: &mut B) -> Result<(), EncodeError>
-where
-    B: BufMut,
-{
-    let length = length as u64;
-    let required = encoded_len_varint(length);
-    let remaining = buf.remaining_mut();
-    if required > remaining {
-        return Err(EncodeError::new(required, remaining));
-    }
-    encode_varint(length, buf);
-    Ok(())
-}
-
-/// Returns the encoded length of a length delimiter.
-///
-/// Applications may use this method to ensure sufficient buffer capacity before calling
-/// `encode_length_delimiter`. The returned size will be between 1 and 10, inclusive.
-pub fn length_delimiter_len(length: usize) -> usize {
-    encoded_len_varint(length as u64)
-}
-
-/// Decodes a length delimiter from the buffer.
-///
-/// This method allows the length delimiter to be decoded independently of the message, when the
-/// message is encoded with [Message.encode_length_delimited].
-///
-/// An error may be returned in two cases:
-///
-///  * If the supplied buffer contains fewer than 10 bytes, then an error indicates that more
-///    input is required to decode the full delimiter.
-///  * If the supplied buffer contains more than 10 bytes, then the buffer contains an invalid
-///    delimiter, and typically the buffer should be considered corrupt.
-pub fn decode_length_delimiter<B>(mut buf: B) -> Result<usize, DecodeError>
-where
-    B: Buf,
-{
-    let length = decode_varint(&mut buf)?;
-    if length > usize::max_value() as u64 {
-        return Err(DecodeError::new(
-            "length delimiter exceeds maximum usize value",
-        ));
-    }
-    Ok(length as usize)
-}
-
 // Re-export #[derive(Message, Enumeration, Oneof)].
 // Based on serde's equivalent re-export [1], but enabled by default.
 //
 // [1]: https://github.com/serde-rs/serde/blob/v1.0.89/serde/src/lib.rs#L245-L256
-#[cfg(feature = "prost-derive")]
+#[cfg(feature = "derive")]
 #[allow(unused_imports)]
 #[macro_use]
 extern crate prost_derive;
-#[cfg(feature = "prost-derive")]
+#[cfg(feature = "derive")]
 #[doc(hidden)]
 pub use prost_derive::*;
diff --git a/third_party/rust/prost/src/message.rs b/third_party/rust/prost/src/message.rs
@@ -1,14 +1,15 @@
+#[cfg(not(feature = "std"))]
 use alloc::boxed::Box;
+#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 use core::fmt::Debug;
-use core::usize;
 
 use bytes::{Buf, BufMut};
 
-use crate::encoding::{
-    decode_key, encode_varint, encoded_len_varint, message, DecodeContext, WireType,
-};
+use crate::encoding::varint::{encode_varint, encoded_len_varint};
+use crate::encoding::wire_type::WireType;
+use crate::encoding::{decode_key, message, DecodeContext};
 use crate::DecodeError;
 use crate::EncodeError;
 
@@ -20,24 +21,22 @@ pub trait Message: Debug + Send + Sync {
     ///
     /// Meant to be used only by `Message` implementations.
     #[doc(hidden)]
-    fn encode_raw<B>(&self, buf: &mut B)
+    fn encode_raw(&self, buf: &mut impl BufMut)
     where
-        B: BufMut,
         Self: Sized;
 
     /// Decodes a field from a buffer, and merges it into `self`.
     ///
     /// Meant to be used only by `Message` implementations.
     #[doc(hidden)]
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
     ) -> Result<(), DecodeError>
     where
-        B: Buf,
         Self: Sized;
 
     /// Returns the encoded length of the message without a length delimiter.
@@ -46,14 +45,13 @@ pub trait Message: Debug + Send + Sync {
     /// Encodes the message to a buffer.
     ///
     /// An error will be returned if the buffer does not have sufficient capacity.
-    fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>
+    fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>
     where
-        B: BufMut,
         Self: Sized,
     {
         let required = self.encoded_len();
         let remaining = buf.remaining_mut();
-        if required > buf.remaining_mut() {
+        if required > remaining {
             return Err(EncodeError::new(required, remaining));
         }
 
@@ -75,9 +73,8 @@ pub trait Message: Debug + Send + Sync {
     /// Encodes the message with a length-delimiter to a buffer.
     ///
     /// An error will be returned if the buffer does not have sufficient capacity.
-    fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>
+    fn encode_length_delimited(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>
     where
-        B: BufMut,
         Self: Sized,
     {
         let len = self.encoded_len();
@@ -107,9 +104,8 @@ pub trait Message: Debug + Send + Sync {
     /// Decodes an instance of the message from a buffer.
     ///
     /// The entire buffer will be consumed.
-    fn decode<B>(mut buf: B) -> Result<Self, DecodeError>
+    fn decode(mut buf: impl Buf) -> Result<Self, DecodeError>
     where
-        B: Buf,
         Self: Default,
     {
         let mut message = Self::default();
@@ -117,9 +113,8 @@ pub trait Message: Debug + Send + Sync {
     }
 
     /// Decodes a length-delimited instance of the message from the buffer.
-    fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>
+    fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>
     where
-        B: Buf,
         Self: Default,
     {
         let mut message = Self::default();
@@ -130,9 +125,8 @@ pub trait Message: Debug + Send + Sync {
     /// Decodes an instance of the message from a buffer, and merges it into `self`.
     ///
     /// The entire buffer will be consumed.
-    fn merge<B>(&mut self, mut buf: B) -> Result<(), DecodeError>
+    fn merge(&mut self, mut buf: impl Buf) -> Result<(), DecodeError>
     where
-        B: Buf,
         Self: Sized,
     {
         let ctx = DecodeContext::default();
@@ -145,9 +139,8 @@ pub trait Message: Debug + Send + Sync {
 
     /// Decodes a length-delimited instance of the message from buffer, and
     /// merges it into `self`.
-    fn merge_length_delimited<B>(&mut self, mut buf: B) -> Result<(), DecodeError>
+    fn merge_length_delimited(&mut self, mut buf: impl Buf) -> Result<(), DecodeError>
     where
-        B: Buf,
         Self: Sized,
     {
         message::merge(
@@ -166,22 +159,16 @@ impl<M> Message for Box<M>
 where
     M: Message,
 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         (**self).encode_raw(buf)
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         (**self).merge_field(tag, wire_type, buf, ctx)
     }
     fn encoded_len(&self) -> usize {
diff --git a/third_party/rust/prost/src/name.rs b/third_party/rust/prost/src/name.rs
@@ -1,27 +1,33 @@
 //! Support for associating type name information with a [`Message`].
 
 use crate::Message;
+
+#[cfg(not(feature = "std"))]
 use alloc::{format, string::String};
 
 /// Associate a type name with a [`Message`] type.
 pub trait Name: Message {
-    /// Type name for this [`Message`]. This is the camel case name,
-    /// e.g. `TypeName`.
+    /// Simple name for this [`Message`].
+    /// This name is the same as it appears in the source .proto file, e.g. `FooBar`.
     const NAME: &'static str;
 
     /// Package name this message type is contained in. They are domain-like
     /// and delimited by `.`, e.g. `google.protobuf`.
     const PACKAGE: &'static str;
 
-    /// Full name of this message type containing both the package name and
-    /// type name, e.g. `google.protobuf.TypeName`.
+    /// Fully-qualified unique name for this [`Message`].
+    /// It's prefixed with the package name and names of any parent messages,
+    /// e.g. `google.rpc.BadRequest.FieldViolation`.
+    /// By default, this is the package name followed by the message name.
+    /// Fully-qualified names must be unique within a domain of Type URLs.
     fn full_name() -> String {
-        format!("{}.{}", Self::NAME, Self::PACKAGE)
+        format!("{}.{}", Self::PACKAGE, Self::NAME)
     }
 
-    /// Type URL for this message, which by default is the full name with a
+    /// Type URL for this [`Message`], which by default is the full name with a
     /// leading slash, but may also include a leading domain name, e.g.
     /// `type.googleapis.com/google.profile.Person`.
+    /// This can be used when serializing into the `google.protobuf.Any` type.
     fn type_url() -> String {
         format!("/{}", Self::full_name())
     }
diff --git a/third_party/rust/prost/src/types.rs b/third_party/rust/prost/src/types.rs
@@ -5,39 +5,34 @@
 //! the `prost-types` crate in order to avoid a cyclic dependency between `prost` and
 //! `prost-build`.
 
+use alloc::format;
 use alloc::string::String;
 use alloc::vec::Vec;
 
 use ::bytes::{Buf, BufMut, Bytes};
 
+use crate::encoding::wire_type::WireType;
 use crate::{
     encoding::{
-        bool, bytes, double, float, int32, int64, skip_field, string, uint32, uint64,
-        DecodeContext, WireType,
+        bool, bytes, double, float, int32, int64, skip_field, string, uint32, uint64, DecodeContext,
     },
-    DecodeError, Message,
+    DecodeError, Message, Name,
 };
 
 /// `google.protobuf.BoolValue`
 impl Message for bool {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self {
             bool::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             bool::merge(wire_type, self, buf, ctx)
         } else {
@@ -56,26 +51,30 @@ impl Message for bool {
     }
 }
 
+/// `google.protobuf.BoolValue`
+impl Name for bool {
+    const NAME: &'static str = "BoolValue";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.UInt32Value`
 impl Message for u32 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self != 0 {
             uint32::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             uint32::merge(wire_type, self, buf, ctx)
         } else {
@@ -94,26 +93,30 @@ impl Message for u32 {
     }
 }
 
+/// `google.protobuf.UInt32Value`
+impl Name for u32 {
+    const NAME: &'static str = "UInt32Value";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.UInt64Value`
 impl Message for u64 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self != 0 {
             uint64::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             uint64::merge(wire_type, self, buf, ctx)
         } else {
@@ -132,26 +135,30 @@ impl Message for u64 {
     }
 }
 
+/// `google.protobuf.UInt64Value`
+impl Name for u64 {
+    const NAME: &'static str = "UInt64Value";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.Int32Value`
 impl Message for i32 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self != 0 {
             int32::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             int32::merge(wire_type, self, buf, ctx)
         } else {
@@ -170,26 +177,30 @@ impl Message for i32 {
     }
 }
 
+/// `google.protobuf.Int32Value`
+impl Name for i32 {
+    const NAME: &'static str = "Int32Value";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.Int64Value`
 impl Message for i64 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self != 0 {
             int64::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             int64::merge(wire_type, self, buf, ctx)
         } else {
@@ -208,26 +219,30 @@ impl Message for i64 {
     }
 }
 
+/// `google.protobuf.Int64Value`
+impl Name for i64 {
+    const NAME: &'static str = "Int64Value";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.FloatValue`
 impl Message for f32 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self != 0.0 {
             float::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             float::merge(wire_type, self, buf, ctx)
         } else {
@@ -246,26 +261,30 @@ impl Message for f32 {
     }
 }
 
+/// `google.protobuf.FloatValue`
+impl Name for f32 {
+    const NAME: &'static str = "FloatValue";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.DoubleValue`
 impl Message for f64 {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if *self != 0.0 {
             double::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             double::merge(wire_type, self, buf, ctx)
         } else {
@@ -284,26 +303,30 @@ impl Message for f64 {
     }
 }
 
+/// `google.protobuf.DoubleValue`
+impl Name for f64 {
+    const NAME: &'static str = "DoubleValue";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.StringValue`
 impl Message for String {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if !self.is_empty() {
             string::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             string::merge(wire_type, self, buf, ctx)
         } else {
@@ -322,26 +345,30 @@ impl Message for String {
     }
 }
 
+/// `google.protobuf.StringValue`
+impl Name for String {
+    const NAME: &'static str = "StringValue";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.BytesValue`
 impl Message for Vec<u8> {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if !self.is_empty() {
             bytes::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             bytes::merge(wire_type, self, buf, ctx)
         } else {
@@ -361,25 +388,29 @@ impl Message for Vec<u8> {
 }
 
 /// `google.protobuf.BytesValue`
+impl Name for Vec<u8> {
+    const NAME: &'static str = "BytesValue";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
+/// `google.protobuf.BytesValue`
 impl Message for Bytes {
-    fn encode_raw<B>(&self, buf: &mut B)
-    where
-        B: BufMut,
-    {
+    fn encode_raw(&self, buf: &mut impl BufMut) {
         if !self.is_empty() {
             bytes::encode(1, self, buf)
         }
     }
-    fn merge_field<B>(
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         if tag == 1 {
             bytes::merge(wire_type, self, buf, ctx)
         } else {
@@ -398,23 +429,26 @@ impl Message for Bytes {
     }
 }
 
+/// `google.protobuf.BytesValue`
+impl Name for Bytes {
+    const NAME: &'static str = "BytesValue";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
 /// `google.protobuf.Empty`
 impl Message for () {
-    fn encode_raw<B>(&self, _buf: &mut B)
-    where
-        B: BufMut,
-    {
-    }
-    fn merge_field<B>(
+    fn encode_raw(&self, _buf: &mut impl BufMut) {}
+    fn merge_field(
         &mut self,
         tag: u32,
         wire_type: WireType,
-        buf: &mut B,
+        buf: &mut impl Buf,
         ctx: DecodeContext,
-    ) -> Result<(), DecodeError>
-    where
-        B: Buf,
-    {
+    ) -> Result<(), DecodeError> {
         skip_field(wire_type, tag, buf, ctx)
     }
     fn encoded_len(&self) -> usize {
@@ -422,3 +456,115 @@ impl Message for () {
     }
     fn clear(&mut self) {}
 }
+
+/// `google.protobuf.Empty`
+impl Name for () {
+    const NAME: &'static str = "Empty";
+    const PACKAGE: &'static str = "google.protobuf";
+
+    fn type_url() -> String {
+        googleapis_type_url_for::<Self>()
+    }
+}
+
+/// Compute the type URL for the given `google.protobuf` type, using `type.googleapis.com` as the
+/// authority for the URL.
+fn googleapis_type_url_for<T: Name>() -> String {
+    format!("type.googleapis.com/{}.{}", T::PACKAGE, T::NAME)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_impl_name() {
+        assert_eq!("BoolValue", bool::NAME);
+        assert_eq!("google.protobuf", bool::PACKAGE);
+        assert_eq!("google.protobuf.BoolValue", bool::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.BoolValue",
+            bool::type_url()
+        );
+
+        assert_eq!("UInt32Value", u32::NAME);
+        assert_eq!("google.protobuf", u32::PACKAGE);
+        assert_eq!("google.protobuf.UInt32Value", u32::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.UInt32Value",
+            u32::type_url()
+        );
+
+        assert_eq!("UInt64Value", u64::NAME);
+        assert_eq!("google.protobuf", u64::PACKAGE);
+        assert_eq!("google.protobuf.UInt64Value", u64::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.UInt64Value",
+            u64::type_url()
+        );
+
+        assert_eq!("Int32Value", i32::NAME);
+        assert_eq!("google.protobuf", i32::PACKAGE);
+        assert_eq!("google.protobuf.Int32Value", i32::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.Int32Value",
+            i32::type_url()
+        );
+
+        assert_eq!("Int64Value", i64::NAME);
+        assert_eq!("google.protobuf", i64::PACKAGE);
+        assert_eq!("google.protobuf.Int64Value", i64::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.Int64Value",
+            i64::type_url()
+        );
+
+        assert_eq!("FloatValue", f32::NAME);
+        assert_eq!("google.protobuf", f32::PACKAGE);
+        assert_eq!("google.protobuf.FloatValue", f32::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.FloatValue",
+            f32::type_url()
+        );
+
+        assert_eq!("DoubleValue", f64::NAME);
+        assert_eq!("google.protobuf", f64::PACKAGE);
+        assert_eq!("google.protobuf.DoubleValue", f64::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.DoubleValue",
+            f64::type_url()
+        );
+
+        assert_eq!("StringValue", String::NAME);
+        assert_eq!("google.protobuf", String::PACKAGE);
+        assert_eq!("google.protobuf.StringValue", String::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.StringValue",
+            String::type_url()
+        );
+
+        assert_eq!("BytesValue", Vec::<u8>::NAME);
+        assert_eq!("google.protobuf", Vec::<u8>::PACKAGE);
+        assert_eq!("google.protobuf.BytesValue", Vec::<u8>::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.BytesValue",
+            Vec::<u8>::type_url()
+        );
+
+        assert_eq!("BytesValue", Bytes::NAME);
+        assert_eq!("google.protobuf", Bytes::PACKAGE);
+        assert_eq!("google.protobuf.BytesValue", Bytes::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.BytesValue",
+            Bytes::type_url()
+        );
+
+        assert_eq!("Empty", <()>::NAME);
+        assert_eq!("google.protobuf", <()>::PACKAGE);
+        assert_eq!("google.protobuf.Empty", <()>::full_name());
+        assert_eq!(
+            "type.googleapis.com/google.protobuf.Empty",
+            <()>::type_url()
+        );
+    }
+}
diff --git a/third_party/rust/remote_settings/.cargo-checksum.json b/third_party/rust/remote_settings/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"19c95234033bcb34a4f179937308bd6075c8df6671d7b2f34b897fc3c33718e6","dumps/main/attachments/regions/world":"00b308033d44f61612b962f572765d14a3999586d92fc8b9fff2217a1ae070e8","dumps/main/attachments/regions/world-buffered":"1d3ed6954fac2a5b31302f5d3e8186c5fa08a20239afc0643ca5dfbb4d8a86fc","dumps/main/attachments/regions/world-buffered.meta.json":"914a71376a152036aceccb6877e079fbb9e3373c6219f24f00dd30e901a72cce","dumps/main/attachments/regions/world.meta.json":"2a47d77834997b98e563265d299723e7f7fd64c8c7a5731afc722862333d6fbd","dumps/main/attachments/search-config-icons/001500a9-1a6c-3f5a-ba15-a5f5a075d256":"fdadf15c6eae7933c3d254ae6311112e0bc8a422c38c758189dbe6a4d7f6b718","dumps/main/attachments/search-config-icons/001500a9-1a6c-3f5a-ba15-a5f5a075d256.meta.json":"6ed1e1c390a45360590e5a1e6d7823218e7b10860581646ddb5e368143aa72fc","dumps/main/attachments/search-config-icons/06cf7432-efd7-f244-927b-5e423005e1ea":"b75ef04a805325e303c4195833cdd077d3d406f360b25b72502fc55880b9150b","dumps/main/attachments/search-config-icons/06cf7432-efd7-f244-927b-5e423005e1ea.meta.json":"0d4cce0ed0dc6b2c46651bea32fc3cc2facfe8b341e1022b65f2cd2231f6b713","dumps/main/attachments/search-config-icons/0a57b0cf-34f0-4d09-96e4-dbd6e3355410":"a7493c6a9d70d60acccf73f62dcbc127a580469570aee60b7482cd42cdb59f69","dumps/main/attachments/search-config-icons/0a57b0cf-34f0-4d09-96e4-dbd6e3355410.meta.json":"d33a128c92b96af2e643158ed3b861d3726bd67a59907fed0795ab2210c82b96","dumps/main/attachments/search-config-icons/0d7668a8-c3f4-cfee-cbc8-536511528937":"7042293af6b04e421cb7b68dc599ac644b76939cdcf5970159e44f658dd6a0cc","dumps/main/attachments/search-config-icons/0d7668a8-c3f4-cfee-cbc8-536511528937.meta.json":"d6523508334a67b201326591606d7e225a04fc53fdce2c1b4d8afac1b41af6b0","dumps/main/attachments/search-config-icons/0eec5640-6fde-d6fe-322a-c72c6d5bd5a2":"64800e32b24b2c8c0582750e1657426d56abd74b65682e20e892f82710d120b6","dumps/main/attachments/search-config-icons/0eec5640-6fde-d6fe-322a-c72c6d5bd5a2.meta.json":"56fb61a078cc45abf7bc3b8fe89b60ef75f3b86ea61d63084749607c4662bbef","dumps/main/attachments/search-config-icons/101ce01d-2691-b729-7f16-9d389803384b":"62d2faa3a8322b1f643aab6e045837500ebe3049c5cb140cb44c4dfc7290337a","dumps/main/attachments/search-config-icons/101ce01d-2691-b729-7f16-9d389803384b.meta.json":"de134ed423a2bd92b4ad8cdf631aad6a83cc2c30f8df9ee251a435ee9f46f28f","dumps/main/attachments/search-config-icons/177aba42-9bed-4078-e36b-580e8794cd7f":"3b88f3ef3cbfaed127d679ec7e44a44fe8dcad688feb89a70a1a9447c1460d15","dumps/main/attachments/search-config-icons/177aba42-9bed-4078-e36b-580e8794cd7f.meta.json":"c35210da5afc11b3af156baf46c23fa523dafac7e8cb2738b4caef80ed48c72e","dumps/main/attachments/search-config-icons/25de0352-aabb-d31f-15f7-bf9299fb004c":"828c3ca82e9be483ae583e5a705dde57b24fd8431e192e3a2d0809871992afa5","dumps/main/attachments/search-config-icons/25de0352-aabb-d31f-15f7-bf9299fb004c.meta.json":"aa5483b5c65427c028a676b2fc13892f6fcaf602613183962744c43ca146d86a","dumps/main/attachments/search-config-icons/2bbe48f4-d3b8-c9e0-86e3-a54c37ec3335":"723ac3228124926537d5a61284d60e198a52895195f9f69b967c578ef7a012ad","dumps/main/attachments/search-config-icons/2bbe48f4-d3b8-c9e0-86e3-a54c37ec3335.meta.json":"d754b38d7e2f79e651d5fe110a7bb9855e0f7269e177be6d047453a36a52a4c5","dumps/main/attachments/search-config-icons/2e835b0e-9709-d1bb-9725-87f59f3445ca":"16ea89d4baa39529d7a84d5152867a4c6ed6867198c4dfa1648b1f43ce6a3f6f","dumps/main/attachments/search-config-icons/2e835b0e-9709-d1bb-9725-87f59f3445ca.meta.json":"7edb361a6610fdabb431a58bc170b7df3f179ca1fadebae6f2e98777b64b35c5","dumps/main/attachments/search-config-icons/2ecca3f8-c1ef-43cc-b053-886d1ae46c36":"774f0a7a613c6c5bea642e3628fa7436851de79e7da9713ad0c96d5db7f44300","dumps/main/attachments/search-config-icons/2ecca3f8-c1ef-43cc-b053-886d1ae46c36.meta.json":"194cb07dd29fd66121f05bbef38291e894291adcbc4c63c373b5f72f6f2e245e","dumps/main/attachments/search-config-icons/32d26d19-aeb0-5c01-32e8-f8970be9246f":"a64f553b79fbb8c45734310dac401ad253ccd05aeabfa58bb5541daa6d8caf70","dumps/main/attachments/search-config-icons/32d26d19-aeb0-5c01-32e8-f8970be9246f.meta.json":"6e56cf6a9470f575b283e40ed6a049e9dbffadcb59fa74a0f941b431c444d795","dumps/main/attachments/search-config-icons/39d0b17d-c020-4890-932f-83c0f6ed130b":"4f409c3ffc67cfa870b05e4089b6ffc3fc81448fa60afba447f0177cd1192b1e","dumps/main/attachments/search-config-icons/39d0b17d-c020-4890-932f-83c0f6ed130b.meta.json":"686c72d6cd220285d8b97af55474198027eab1b1af7ed89508c8935c9e00e7d4","dumps/main/attachments/search-config-icons/41135a88-093d-4077-873b-9de1ae133427":"c2718c5e416670426475dd8cc496f5464bf95224e8f8f0a72b695360ddc917c0","dumps/main/attachments/search-config-icons/41135a88-093d-4077-873b-9de1ae133427.meta.json":"a941fc27ca88b56eccbdec380ce2d3b911f4c62e4aba1f5399bc4498c6601d94","dumps/main/attachments/search-config-icons/41f0d805-3775-4988-8d8c-5ad8ccd86d1c":"755b8939c63b1fcc9acd05cd33ffed675397516d37b5bd8f3a03875e25d3fb43","dumps/main/attachments/search-config-icons/41f0d805-3775-4988-8d8c-5ad8ccd86d1c.meta.json":"25cafe7d629c6b006e15dee98987c26ef509f348ed0350a3ccf1f06838db86f3","dumps/main/attachments/search-config-icons/47da97b5-600f-c450-fd15-a52bb2169c11":"d7fdfd971d874f2ec6f209df6f6b8173d126cd3f7a25daacb94de4259efbcf16","dumps/main/attachments/search-config-icons/47da97b5-600f-c450-fd15-a52bb2169c11.meta.json":"e6b95ca29bf3e750819cf890ae8e879ac506d54b918c3c0ab065adc16a131188","dumps/main/attachments/search-config-icons/48c72361-cd67-412e-bd7f-f81a43c10791":"92da7ef030e1d3ed97235748156383e5d75fa6d2744bd124334ab47dc0b689a1","dumps/main/attachments/search-config-icons/48c72361-cd67-412e-bd7f-f81a43c10791.meta.json":"21d1320d60c981b9c9248b9b186fc49f9d95046a817d7a3145f48465236087e8","dumps/main/attachments/search-config-icons/4e271681-3e0f-91ac-9750-03f665efc171":"189ed3031a2cefd3150c9e5b37bee1ffbc1f7850f7ac0621e4b8d262f2c1048c","dumps/main/attachments/search-config-icons/4e271681-3e0f-91ac-9750-03f665efc171.meta.json":"0a401871b82f1c1cbca91232fd643be1cc1a76c07a48830eaa2a47cdfafb1f14","dumps/main/attachments/search-config-icons/50f6171f-8e7a-b41b-862e-f97397038fb2":"9140bd1b30953f41bc758d2c0ecc873f5163e4f51126c278991eccd38589c541","dumps/main/attachments/search-config-icons/50f6171f-8e7a-b41b-862e-f97397038fb2.meta.json":"805d8ce33bac4611ce12d1f84ef431313555d76bf996264736e401ceb6dabe98","dumps/main/attachments/search-config-icons/5203dd03-2c55-4b53-9c60-58258d587be1":"adb29f6fd95956401630d94967381ac473f57215d96a5bcf500a00e747731380","dumps/main/attachments/search-config-icons/5203dd03-2c55-4b53-9c60-58258d587be1.meta.json":"27a6f994c2c7653a33d380ac13c4cfbc00f543a92f229426aa71d85b1f968357","dumps/main/attachments/search-config-icons/5914932e-66ba-4126-8be5-d37beadd9532":"02f54211387baa59e4246356dc7344e48f39a412f2e5993d7f403aa538df7276","dumps/main/attachments/search-config-icons/5914932e-66ba-4126-8be5-d37beadd9532.meta.json":"2df77daeeef5892fdb7fdeecffb804638bd0d2f7da5b9e617f01303d786dcd09","dumps/main/attachments/search-config-icons/5ded611d-44b2-dc46-fd67-fb116888d75d":"877fb3aca13d2a7c656df1f94df3fa052afbb40b65c99ba5382392ff5499016e","dumps/main/attachments/search-config-icons/5ded611d-44b2-dc46-fd67-fb116888d75d.meta.json":"d1c75915fdc86461e755cd08e670b01da41cd3d76688afe692f841733a9b7ee0","dumps/main/attachments/search-config-icons/5e03d6f4-6ee9-8bc8-cf22-7a5f2cf55c41":"9cd3da38e3938549434d1c3cba6fed249ffa7d91d9a6d7ffb5f4184f527cac76","dumps/main/attachments/search-config-icons/5e03d6f4-6ee9-8bc8-cf22-7a5f2cf55c41.meta.json":"8506d9438825f2dc34875e04e0212e22a2652c5c43aa93e4d184d59ec765316f","dumps/main/attachments/search-config-icons/6644f26f-28ea-4222-929d-5d43a02dae05":"4f1bfbfec1441bd9a304ca7f3b8fd54130e94df185f7b28bb17c86ba517e13b7","dumps/main/attachments/search-config-icons/6644f26f-28ea-4222-929d-5d43a02dae05.meta.json":"f7d37f9c8b87480539cd981f463790c99ed15b2ffc5e3ff4786dd11c25228df4","dumps/main/attachments/search-config-icons/6d10d702-7bd6-1452-90a5-3df665a38f66":"f895a965b68d02e7391cc4504d9be75e1ba7f9b50a1dd59af77bb44a7769c08c","dumps/main/attachments/search-config-icons/6d10d702-7bd6-1452-90a5-3df665a38f66.meta.json":"d782d80f8187cf8051be89c6b8a1ef4700e0b84dcda006843d1fd2f266c4419b","dumps/main/attachments/search-config-icons/6e36a151-e4f4-4117-9067-1ca82c47d01a":"e9849089ffced59563896974afee0fceedac7fc8455bbeaa5bae230f54c933d9","dumps/main/attachments/search-config-icons/6e36a151-e4f4-4117-9067-1ca82c47d01a.meta.json":"0e5a64c06ea0ae875e8e0fdc850feddf5a8714b8290293dcd100d455de32ace0","dumps/main/attachments/search-config-icons/6f4da442-d31e-28f8-03af-797d16bbdd27":"dd5cab3711f778677859e86000a127ed07a6175e8e58aecb0fba71b825ce76d7","dumps/main/attachments/search-config-icons/6f4da442-d31e-28f8-03af-797d16bbdd27.meta.json":"0a947797180fdaf031a9c2d2f841b88243c90ff85f0af873f99ddd770fc59e8b","dumps/main/attachments/search-config-icons/7072564d-a573-4750-bf33-f0a07631c9eb":"0a653ea57472694ac05623d9b237e479232a0d65683d05f89661f996054e3276","dumps/main/attachments/search-config-icons/7072564d-a573-4750-bf33-f0a07631c9eb.meta.json":"bb8a256f72b37166fea2ecd4c3a59f49615854a7210e6963f2571f8dcb3d3a3f","dumps/main/attachments/search-config-icons/70fdd651-6c50-b7bb-09ec-7e85da259173":"31a793dad95b5ffd02d39ebf14fc40877596f418f5926247487265034181dc8f","dumps/main/attachments/search-config-icons/70fdd651-6c50-b7bb-09ec-7e85da259173.meta.json":"8c744e9d2f218256e63f1b1a2193f2fc4a7b980e72464e8d57fbe150446f2efc","dumps/main/attachments/search-config-icons/71f41a0c-5b70-4116-b30f-e62089083522":"5aad083bfcef256d433c1ffa571b814d16f61832bcd7565bf03909011f6a0bfc","dumps/main/attachments/search-config-icons/71f41a0c-5b70-4116-b30f-e62089083522.meta.json":"4a8f0c4e4ee643faa2f8d8cc4ddb8f87d14c740e8c9252223f826181c0117741","dumps/main/attachments/search-config-icons/74793ce1-a918-a5eb-d3c0-2aadaff3c88c":"ca8f102ac4f35189ebcb786d080843b603b234f89b8d8b1c0ef27a0ab7148182","dumps/main/attachments/search-config-icons/74793ce1-a918-a5eb-d3c0-2aadaff3c88c.meta.json":"60a7975cd79156623b0ca58be4110d152e50b6e9caaaa211dad1cd37eabb0345","dumps/main/attachments/search-config-icons/74f94dc2-caf6-4b90-b3d2-f3e2f7714d88":"3376e14529ed2e96c7dc491b3bf11914d7c8ff47a068311b2432c086c2ae0f28","dumps/main/attachments/search-config-icons/74f94dc2-caf6-4b90-b3d2-f3e2f7714d88.meta.json":"3a94a78a846f312c85c0609971b153aaba9819e2b657f25e3b0648a3956933d1","dumps/main/attachments/search-config-icons/764e3b14-fe16-4feb-8384-124c516a5afa":"71413ef23ac14ce2b7bb76f7f5d16b2df267239841a88ddab36b129481e00616","dumps/main/attachments/search-config-icons/764e3b14-fe16-4feb-8384-124c516a5afa.meta.json":"2f16dd51ade97a327d4e5f14d689f822a5c9061b9b27810bbccbf2f406a5e56f","dumps/main/attachments/search-config-icons/7bbe6c5c-fdb8-2845-a4f4-e1382e708a0e":"24daa27a3234d01b5add42e027b0a34000d0ab47c17fe3924c2ca267b7b61c19","dumps/main/attachments/search-config-icons/7bbe6c5c-fdb8-2845-a4f4-e1382e708a0e.meta.json":"308d345dbcfd7583e5f7460d34caf3b63d01b747a6e060a2b0971bf00ed2b22c","dumps/main/attachments/search-config-icons/7bf4ca37-e2b8-4d31-a1c3-979bc0e85131":"912d20feefcba57d43bffff5e245b8c1e3865155ed686d8ad253bbab71116e83","dumps/main/attachments/search-config-icons/7bf4ca37-e2b8-4d31-a1c3-979bc0e85131.meta.json":"3ec071b0a2940cd8892a72bd28d44237aecfd20d88303661348257ddb98aee43","dumps/main/attachments/search-config-icons/7c81cf98-7c11-4afd-8279-db89118a6dfb":"e988445d87afe0d285bea251705fc23eb70ac42426ab0d7a69d9276585c5573c","dumps/main/attachments/search-config-icons/7c81cf98-7c11-4afd-8279-db89118a6dfb.meta.json":"273dd09cad2a62459cc062e3b39b835d55a06b10cb7d5149aad77dd55451821f","dumps/main/attachments/search-config-icons/7cb4d88a-d4df-45b2-87e4-f896eaf1bbdb":"8dc2e75e6792b8374b20621fa2151ac24b4626e5c1f6a1abec4f912746441859","dumps/main/attachments/search-config-icons/7cb4d88a-d4df-45b2-87e4-f896eaf1bbdb.meta.json":"21d2522ab4e47477e72da3a2d2223e50e55fef442e2ba736d56df1e09593d76f","dumps/main/attachments/search-config-icons/7edaf4fe-a8a0-432b-86d2-bf75ebe80851":"27541cb376bdda829a6cf9cefd13da112728881e3daa4ac3c1178d4ce15f1e8b","dumps/main/attachments/search-config-icons/7edaf4fe-a8a0-432b-86d2-bf75ebe80851.meta.json":"3aea5d0652172940ac33e32628dcc6a03b79fe686c6de752482c8e3ae5cd70eb","dumps/main/attachments/search-config-icons/7efbed51-813c-581d-d8d3-f8758434e451":"b0c6d1850265e3c946917232ca6c6ace3dad23347bfab4f81351eac569326d34","dumps/main/attachments/search-config-icons/7efbed51-813c-581d-d8d3-f8758434e451.meta.json":"5a723c8f04bffa33a69a7054d30a4816caf1a3924081c85e1d9770126f761a96","dumps/main/attachments/search-config-icons/84bb4962-e571-227a-9ef6-2ac5f2aac361":"a1fd5d127a5f2590ddcd439b7a2abb3456b48217ea11daf0345b26e108f520e6","dumps/main/attachments/search-config-icons/84bb4962-e571-227a-9ef6-2ac5f2aac361.meta.json":"5cb0ebdde367b9754ddf6cbd01150414d27977b2d4c5f65cd6bbb89989388f3b","dumps/main/attachments/search-config-icons/87ac4cde-f581-398b-1e32-eb4079183b36":"33ca72f1eac56793d1fd811189cedef98004a067c85b1143083b564814a4b0db","dumps/main/attachments/search-config-icons/87ac4cde-f581-398b-1e32-eb4079183b36.meta.json":"d97eca8063cc17b99c81c55d4ff121d765c793e006ed252fec5f9539bd0fc339","dumps/main/attachments/search-config-icons/8831ce10-b1e4-6eb4-4975-83c67457288e":"ca3cc8786977f6ffeb0546ff8f3bb2b7fd240d1956fbf86777dbf0e8bec9c03b","dumps/main/attachments/search-config-icons/8831ce10-b1e4-6eb4-4975-83c67457288e.meta.json":"45274d848d1f6d398563bb46a2bfa3eee40ff16a5dbf0bbc8904db442f80702c","dumps/main/attachments/search-config-icons/890de5c4-0941-a116-473a-5d240e79497a":"6ba1f0fd1d12014cab32f74daab24dfa16fb26613ace20a1e595267621038a07","dumps/main/attachments/search-config-icons/890de5c4-0941-a116-473a-5d240e79497a.meta.json":"107547059360c3658dcf187a546ffb52bb23fa385e1338151043bebe82bbf640","dumps/main/attachments/search-config-icons/8abb10a7-212f-46b5-a7b4-244f414e3810":"f8780adb4d7b28f2f881db4ca7b697d8fc916cd9fa834ccc445fe7d4b72a6cc7","dumps/main/attachments/search-config-icons/8abb10a7-212f-46b5-a7b4-244f414e3810.meta.json":"5401603c7abbc6ca5bdddb8f9cca7eee2e26e5721cc73f23d95f600d5421d431","dumps/main/attachments/search-config-icons/91a9672d-e945-8e1e-0996-aefdb0190716":"5d53ef1866a08cc29011f5f2a9ce99bbf37cf42e80de7f0e8cc30d13337e8187","dumps/main/attachments/search-config-icons/91a9672d-e945-8e1e-0996-aefdb0190716.meta.json":"4e8ea36e3d659eb22ac7c86498003ca8885bab9c40685bb8ca7796a8230201da","dumps/main/attachments/search-config-icons/94a84724-c30f-4767-ba42-01cc37fc31a4":"98dca7e24cad0a1be96ef2c323e9759beb63c72440756f887e2482d9ce8e8969","dumps/main/attachments/search-config-icons/94a84724-c30f-4767-ba42-01cc37fc31a4.meta.json":"1070966901fe9db82b71bfa74ddeedd4f23ab2ed1eddaf201634e06a604e6006","dumps/main/attachments/search-config-icons/95ed201d-4ab8-4cb8-831d-454f53cab0f8":"3426b5100a6bdb45f8039f0c71a6b68193750ba7bae5b36e5ed31b2b7f372cda","dumps/main/attachments/search-config-icons/95ed201d-4ab8-4cb8-831d-454f53cab0f8.meta.json":"3447cd050619c1d2e5859147ab894a43da75235a580219306d8629e28a7a3eb5","dumps/main/attachments/search-config-icons/96327a73-c433-5eb4-a16d-b090cadfb80b":"ca6e972004f62355c1ea97656bc2328e1643971bdecab9c6b563d45593b8122e","dumps/main/attachments/search-config-icons/96327a73-c433-5eb4-a16d-b090cadfb80b.meta.json":"c4e3c9e6426e6f35410c287eef95b3e2134e54409e462f02dd440876c06b1bb4","dumps/main/attachments/search-config-icons/9802e63d-05ec-48ba-93f9-746e0981ad98":"6b1b073183eb0012daea0dce351a94d395c8a0b531b610e56eac52b3d1d1da0e","dumps/main/attachments/search-config-icons/9802e63d-05ec-48ba-93f9-746e0981ad98.meta.json":"cceb55c68db8dddd23d064364a281e982069bfe2bb55eba7d282fffcec2aa89f","dumps/main/attachments/search-config-icons/9d96547d-7575-49ca-8908-1e046b8ea90e":"6a743574353de0ec7c85b49f46b2b554caa0fc1d064b90544c5dea0fea2b8901","dumps/main/attachments/search-config-icons/9d96547d-7575-49ca-8908-1e046b8ea90e.meta.json":"10897754c5aafe0b84413afee5e9948fd799262a26aa07bca85fe6fb369beac4","dumps/main/attachments/search-config-icons/a06db97d-1210-ea2e-5474-0e2f7d295bfd":"617dec5d635efb0a12d0de935c6999ef0249f4a63c62bdcb96551518bc3d1812","dumps/main/attachments/search-config-icons/a06db97d-1210-ea2e-5474-0e2f7d295bfd.meta.json":"06cf576ca882bd7c2d54c18329e21e5b1a9cb7732d4954b52cbfa52979a67765","dumps/main/attachments/search-config-icons/a06dc3fd-4bdb-41f3-2ebc-4cbed06a9bd3":"d994f806b1e4225b50be5ab681b2cecf845cc216a19a432d878cea3cb815bafd","dumps/main/attachments/search-config-icons/a06dc3fd-4bdb-41f3-2ebc-4cbed06a9bd3.meta.json":"67524e18799023a017c7d9db1b9ba5c9cc3090d20f8154449a8f44ba22719104","dumps/main/attachments/search-config-icons/a2c7d4e9-f770-51e1-0963-3c2c8401631d":"1bf68aca7bfc75ca8485c3dac9a1daa13c1a3eb480688c32262096af6076adfa","dumps/main/attachments/search-config-icons/a2c7d4e9-f770-51e1-0963-3c2c8401631d.meta.json":"4ab103bba0f8fde581c3950c6c08cfcf6786104d8cbcba240499308f26958d04","dumps/main/attachments/search-config-icons/a83f24e4-602c-47bd-930c-ad0947ee1adf":"66612f999921d892645c8a2b37aa5dad17b134e7fdaed375a683baec7fc10697","dumps/main/attachments/search-config-icons/a83f24e4-602c-47bd-930c-ad0947ee1adf.meta.json":"f985ffbde6cf6ef972b6798c9336922dcfa29ca9a31e3aa4fae1962e069bdb0c","dumps/main/attachments/search-config-icons/b64f09fd-52d1-c48e-af23-4ce918e7bf3b":"c3e8300801c5c585662f14fd8e819d635efd9830783dc3c631212927866e9898","dumps/main/attachments/search-config-icons/b64f09fd-52d1-c48e-af23-4ce918e7bf3b.meta.json":"f7fd846d6717131e75865f8f5ed562e88f40be3dcf1603f2660b425dedabc7d1","dumps/main/attachments/search-config-icons/b882b24d-1776-4ef9-9016-0bdbd935eda3":"076352591c7077af4af5771918f80b5da9c6bf479327cc68390abdb158f3ec03","dumps/main/attachments/search-config-icons/b882b24d-1776-4ef9-9016-0bdbd935eda3.meta.json":"229139bca53bc63bd59b8f261f36c11fbe76b2b45dfeac2580261cf290c41365","dumps/main/attachments/search-config-icons/b8ca5a94-8fff-27ad-6e00-96e244a32e21":"1474c93e49c209aca2a2df2acb61b64574805106bead6edebd67287de21920e0","dumps/main/attachments/search-config-icons/b8ca5a94-8fff-27ad-6e00-96e244a32e21.meta.json":"6fd72c11afb4249d0166d8d98c552ee02d73c0e07f0578bfd3d7e67d70bcaee3","dumps/main/attachments/search-config-icons/b9424309-f601-4a69-98ca-ca68e65633e6":"601d72e7abde5ec864b3d8ca0031896f769107670b84c66053062481a56d8665","dumps/main/attachments/search-config-icons/b9424309-f601-4a69-98ca-ca68e65633e6.meta.json":"f299a7d56c5552fc592c66073d3e1e1d16ce4a99e935dcc0cad7dafcad6b9e3b","dumps/main/attachments/search-config-icons/c411adc1-9661-4fb5-a4c1-8cfe74911943":"150765e8e9b985ba5b820ac9b8e7623023d5a0e24f94663d5e9203d8d7598059","dumps/main/attachments/search-config-icons/c411adc1-9661-4fb5-a4c1-8cfe74911943.meta.json":"c5cc89d5f24ef1fa40b1c47c2e97eaeb01439b8d3b186b9c2fe716c94ead30f2","dumps/main/attachments/search-config-icons/cbf9e891-d079-2b28-5617-283450d463dd":"5b2c34b3c4e8dd898b664dba6c3786e2ff9869eff55d673aa48361f11325ed07","dumps/main/attachments/search-config-icons/cbf9e891-d079-2b28-5617-283450d463dd.meta.json":"b757806fd1b922d81bbecab94c73d3db98cfc2aa2791a4d5137112f795a732ee","dumps/main/attachments/search-config-icons/d87f251c-3e12-a8bf-e2d0-afd43d36c5f9":"865d76c8175a8f11dedc93f0bc212242a97a8a76adac870e8249368cecc81402","dumps/main/attachments/search-config-icons/d87f251c-3e12-a8bf-e2d0-afd43d36c5f9.meta.json":"22594c8870cbabe5fc5d2637509235202502661b466e9e37c5878716f323a34f","dumps/main/attachments/search-config-icons/db0e1627-ae89-4c25-8944-a9481d8512d9":"97a68f0b948b68bbf389a9ef43e2fe6c31ff8dc7889c939fdfdea79378576c67","dumps/main/attachments/search-config-icons/db0e1627-ae89-4c25-8944-a9481d8512d9.meta.json":"1eccc999dcd377af84cf63ed60b7ef23d5d4b936a1e465d12349a5366b1b012d","dumps/main/attachments/search-config-icons/e02f23df-8d48-2b1b-3b5c-6dd27302c61c":"247aa26993083705ce99a8e5612cdf262aca98cde86ba19afc964329ba95986a","dumps/main/attachments/search-config-icons/e02f23df-8d48-2b1b-3b5c-6dd27302c61c.meta.json":"06fc893d29cf406519611da9d1993a13bd9134192940c12bf64536ea571db4f0","dumps/main/attachments/search-config-icons/e718e983-09aa-e8f6-b25f-cd4b395d4785":"809697f48848e7c3638d5f3e0b224ea60b3800504e7bd8417854d55989b85196","dumps/main/attachments/search-config-icons/e718e983-09aa-e8f6-b25f-cd4b395d4785.meta.json":"0d9baef39747776500e5b83e72cd9d901fc09ac08247368dd2117bb4ec011f54","dumps/main/attachments/search-config-icons/e7547f62-187b-b641-d462-e54a3f813d9a":"c971ee33b8c0a57349669d957bf73070b0632b128c94748e845b57d5e15221a4","dumps/main/attachments/search-config-icons/e7547f62-187b-b641-d462-e54a3f813d9a.meta.json":"8ec4f6a7826966f2ff82632ef527366db3452ebc40c90a557602111f0ea956c9","dumps/main/attachments/search-config-icons/eb62e768-151b-45d1-9fe5-9e1d2a5991c5":"aa46b3d1ed8557e5bc7e71988cc6c46b00363b890d2a781973f9dc9073f8dd31","dumps/main/attachments/search-config-icons/eb62e768-151b-45d1-9fe5-9e1d2a5991c5.meta.json":"a06682b589df8dd63b1f25c01630ead55a89217f72c0bc04b391829af3fef59f","dumps/main/attachments/search-config-icons/f312610a-ebfb-a106-ea92-fd643c5d3636":"91d17ba44192a6430ffdb447ff3a11533ef964628f67c13480cc9470212d3d65","dumps/main/attachments/search-config-icons/f312610a-ebfb-a106-ea92-fd643c5d3636.meta.json":"ce26ab2382a7a67a55688330dd74127b4a980610f4030bde8eaaa20b81306559","dumps/main/attachments/search-config-icons/fa0fc42c-d91d-fca7-34eb-806ff46062dc":"6da5620880159634213e197fafca1dde0272153be3e4590818533fab8d040770","dumps/main/attachments/search-config-icons/fa0fc42c-d91d-fca7-34eb-806ff46062dc.meta.json":"0c3c0eb832be884f25186395b8bf08cdbe0a6e2845b9e55e7cbea5d0f183ed7d","dumps/main/attachments/search-config-icons/fca3e3ee-56cd-f474-dc31-307fd24a891d":"c4d88cfa5262f6d2cf76b167281d25821c9e1770684b739ed6ad3cf7277a121b","dumps/main/attachments/search-config-icons/fca3e3ee-56cd-f474-dc31-307fd24a891d.meta.json":"a40c37a5150e3745849f67305fe2fe1e06ef1c3901f6dc604a8e3f6c94e7b624","dumps/main/attachments/search-config-icons/fe75ce3f-1545-400c-b28c-ad771054e69f":"3a9d06951c7c9d2c19cd00533a760b0f8755b1e2e718af81c710297d030fbe44","dumps/main/attachments/search-config-icons/fe75ce3f-1545-400c-b28c-ad771054e69f.meta.json":"3f353e083d7a885f6d59d36c9276a2d325686a533cf8c502cd41a10172e763ea","dumps/main/attachments/search-config-icons/fed4f021-ff3e-942a-010e-afa43fda2136":"d7fdfd971d874f2ec6f209df6f6b8173d126cd3f7a25daacb94de4259efbcf16","dumps/main/attachments/search-config-icons/fed4f021-ff3e-942a-010e-afa43fda2136.meta.json":"740f77dcc93ece89fd55557baf399a4464373c81154b0a9758b8622f6c458253","dumps/main/regions.json":"e8990158373f82d3f89fed5089cf29e4177cc85904479128728e05025e9a0c0c","dumps/main/search-config-icons.json":"8bfa7c4abd2ab4238cd2ea66dc143bb9048f2699735b01560980109dbe39d759","dumps/main/search-config-v2.json":"377a7027e3b50118ca5f198ebc89461674f9d480edd4bff7ba419539280a13f5","dumps/main/search-telemetry-v2.json":"62a96014721bbd546d677eda35e33a71526245a511b32efaa5b6d2ef1f5294e6","dumps/main/summarizer-models-config.json":"545c53023a18e1a91e0817c1d5a5a11e45469516f8813b1a4dcad40426e1464c","src/cache.rs":"c6179802017b43885136e7d64004890cc13e8c2d4742e04073cf404b578f63db","src/client.rs":"c3e54387ebaef56508a0fb66cf891e0c245cd1a0e6e03047cde05b7f6eddee54","src/config.rs":"3e322bdab94855e17427187ffe92a59c1a64c9175d5e1f8605df2f6409a3c93f","src/context.rs":"43bab81026b6f1a2509d129e806fffd09ba80110d656798a02589985017a3c21","src/error.rs":"7f56c3ae167811c5a8413b73a7e6abcec2377c67cf48e7520929e15532678eef","src/jexl_filter.rs":"48a9d960e05dae444421f7c4ceeb45eab656f03f1e7071215c8e8d39aab56b54","src/lib.rs":"cd7d816f87146693471c328a185747e3b786a51f3ddbb780a71f244f18179526","src/macros.rs":"6b06d0ba42ee95235bfd71bac1a0eed02f60c894775ebee64165648b10e932c4","src/schema.rs":"348e0d5ad1840aaae796b537d21381ef91bd75be262138bfec376d9f88d205b3","src/service.rs":"3f0757473194d30d7fb5be75dfe9647640e9d23253f4167139e8bd70468e9abd","src/signatures.rs":"baa2dae76abd8166158fea4676e67e17c17b65af6968de52768350409dbd7092","src/storage.rs":"c33dd92914770e96d3d44dbb9e95f512ce54261710a42c7cf4a896be348c529e","uniffi.toml":"bd7cc0e7c1981f53938f429c4f2541ac454ed4160a8a0b4670659e38acd23ee5"},"package":null}
-\ No newline at end of file
+{"files":{"Cargo.toml":"19c95234033bcb34a4f179937308bd6075c8df6671d7b2f34b897fc3c33718e6","dumps/main/attachments/regions/world":"00b308033d44f61612b962f572765d14a3999586d92fc8b9fff2217a1ae070e8","dumps/main/attachments/regions/world-buffered":"1d3ed6954fac2a5b31302f5d3e8186c5fa08a20239afc0643ca5dfbb4d8a86fc","dumps/main/attachments/regions/world-buffered.meta.json":"914a71376a152036aceccb6877e079fbb9e3373c6219f24f00dd30e901a72cce","dumps/main/attachments/regions/world.meta.json":"2a47d77834997b98e563265d299723e7f7fd64c8c7a5731afc722862333d6fbd","dumps/main/attachments/search-config-icons/001500a9-1a6c-3f5a-ba15-a5f5a075d256":"fdadf15c6eae7933c3d254ae6311112e0bc8a422c38c758189dbe6a4d7f6b718","dumps/main/attachments/search-config-icons/001500a9-1a6c-3f5a-ba15-a5f5a075d256.meta.json":"6ed1e1c390a45360590e5a1e6d7823218e7b10860581646ddb5e368143aa72fc","dumps/main/attachments/search-config-icons/06cf7432-efd7-f244-927b-5e423005e1ea":"b75ef04a805325e303c4195833cdd077d3d406f360b25b72502fc55880b9150b","dumps/main/attachments/search-config-icons/06cf7432-efd7-f244-927b-5e423005e1ea.meta.json":"0d4cce0ed0dc6b2c46651bea32fc3cc2facfe8b341e1022b65f2cd2231f6b713","dumps/main/attachments/search-config-icons/0a57b0cf-34f0-4d09-96e4-dbd6e3355410":"a7493c6a9d70d60acccf73f62dcbc127a580469570aee60b7482cd42cdb59f69","dumps/main/attachments/search-config-icons/0a57b0cf-34f0-4d09-96e4-dbd6e3355410.meta.json":"d33a128c92b96af2e643158ed3b861d3726bd67a59907fed0795ab2210c82b96","dumps/main/attachments/search-config-icons/0d7668a8-c3f4-cfee-cbc8-536511528937":"7042293af6b04e421cb7b68dc599ac644b76939cdcf5970159e44f658dd6a0cc","dumps/main/attachments/search-config-icons/0d7668a8-c3f4-cfee-cbc8-536511528937.meta.json":"d6523508334a67b201326591606d7e225a04fc53fdce2c1b4d8afac1b41af6b0","dumps/main/attachments/search-config-icons/0eec5640-6fde-d6fe-322a-c72c6d5bd5a2":"64800e32b24b2c8c0582750e1657426d56abd74b65682e20e892f82710d120b6","dumps/main/attachments/search-config-icons/0eec5640-6fde-d6fe-322a-c72c6d5bd5a2.meta.json":"56fb61a078cc45abf7bc3b8fe89b60ef75f3b86ea61d63084749607c4662bbef","dumps/main/attachments/search-config-icons/101ce01d-2691-b729-7f16-9d389803384b":"62d2faa3a8322b1f643aab6e045837500ebe3049c5cb140cb44c4dfc7290337a","dumps/main/attachments/search-config-icons/101ce01d-2691-b729-7f16-9d389803384b.meta.json":"de134ed423a2bd92b4ad8cdf631aad6a83cc2c30f8df9ee251a435ee9f46f28f","dumps/main/attachments/search-config-icons/177aba42-9bed-4078-e36b-580e8794cd7f":"3b88f3ef3cbfaed127d679ec7e44a44fe8dcad688feb89a70a1a9447c1460d15","dumps/main/attachments/search-config-icons/177aba42-9bed-4078-e36b-580e8794cd7f.meta.json":"c35210da5afc11b3af156baf46c23fa523dafac7e8cb2738b4caef80ed48c72e","dumps/main/attachments/search-config-icons/25de0352-aabb-d31f-15f7-bf9299fb004c":"828c3ca82e9be483ae583e5a705dde57b24fd8431e192e3a2d0809871992afa5","dumps/main/attachments/search-config-icons/25de0352-aabb-d31f-15f7-bf9299fb004c.meta.json":"aa5483b5c65427c028a676b2fc13892f6fcaf602613183962744c43ca146d86a","dumps/main/attachments/search-config-icons/2bbe48f4-d3b8-c9e0-86e3-a54c37ec3335":"723ac3228124926537d5a61284d60e198a52895195f9f69b967c578ef7a012ad","dumps/main/attachments/search-config-icons/2bbe48f4-d3b8-c9e0-86e3-a54c37ec3335.meta.json":"d754b38d7e2f79e651d5fe110a7bb9855e0f7269e177be6d047453a36a52a4c5","dumps/main/attachments/search-config-icons/2e835b0e-9709-d1bb-9725-87f59f3445ca":"16ea89d4baa39529d7a84d5152867a4c6ed6867198c4dfa1648b1f43ce6a3f6f","dumps/main/attachments/search-config-icons/2e835b0e-9709-d1bb-9725-87f59f3445ca.meta.json":"7edb361a6610fdabb431a58bc170b7df3f179ca1fadebae6f2e98777b64b35c5","dumps/main/attachments/search-config-icons/2ecca3f8-c1ef-43cc-b053-886d1ae46c36":"774f0a7a613c6c5bea642e3628fa7436851de79e7da9713ad0c96d5db7f44300","dumps/main/attachments/search-config-icons/2ecca3f8-c1ef-43cc-b053-886d1ae46c36.meta.json":"194cb07dd29fd66121f05bbef38291e894291adcbc4c63c373b5f72f6f2e245e","dumps/main/attachments/search-config-icons/32d26d19-aeb0-5c01-32e8-f8970be9246f":"a64f553b79fbb8c45734310dac401ad253ccd05aeabfa58bb5541daa6d8caf70","dumps/main/attachments/search-config-icons/32d26d19-aeb0-5c01-32e8-f8970be9246f.meta.json":"6e56cf6a9470f575b283e40ed6a049e9dbffadcb59fa74a0f941b431c444d795","dumps/main/attachments/search-config-icons/39d0b17d-c020-4890-932f-83c0f6ed130b":"4f409c3ffc67cfa870b05e4089b6ffc3fc81448fa60afba447f0177cd1192b1e","dumps/main/attachments/search-config-icons/39d0b17d-c020-4890-932f-83c0f6ed130b.meta.json":"686c72d6cd220285d8b97af55474198027eab1b1af7ed89508c8935c9e00e7d4","dumps/main/attachments/search-config-icons/41135a88-093d-4077-873b-9de1ae133427":"c2718c5e416670426475dd8cc496f5464bf95224e8f8f0a72b695360ddc917c0","dumps/main/attachments/search-config-icons/41135a88-093d-4077-873b-9de1ae133427.meta.json":"a941fc27ca88b56eccbdec380ce2d3b911f4c62e4aba1f5399bc4498c6601d94","dumps/main/attachments/search-config-icons/41f0d805-3775-4988-8d8c-5ad8ccd86d1c":"755b8939c63b1fcc9acd05cd33ffed675397516d37b5bd8f3a03875e25d3fb43","dumps/main/attachments/search-config-icons/41f0d805-3775-4988-8d8c-5ad8ccd86d1c.meta.json":"25cafe7d629c6b006e15dee98987c26ef509f348ed0350a3ccf1f06838db86f3","dumps/main/attachments/search-config-icons/47da97b5-600f-c450-fd15-a52bb2169c11":"d7fdfd971d874f2ec6f209df6f6b8173d126cd3f7a25daacb94de4259efbcf16","dumps/main/attachments/search-config-icons/47da97b5-600f-c450-fd15-a52bb2169c11.meta.json":"e6b95ca29bf3e750819cf890ae8e879ac506d54b918c3c0ab065adc16a131188","dumps/main/attachments/search-config-icons/48c72361-cd67-412e-bd7f-f81a43c10791":"92da7ef030e1d3ed97235748156383e5d75fa6d2744bd124334ab47dc0b689a1","dumps/main/attachments/search-config-icons/48c72361-cd67-412e-bd7f-f81a43c10791.meta.json":"21d1320d60c981b9c9248b9b186fc49f9d95046a817d7a3145f48465236087e8","dumps/main/attachments/search-config-icons/4e271681-3e0f-91ac-9750-03f665efc171":"189ed3031a2cefd3150c9e5b37bee1ffbc1f7850f7ac0621e4b8d262f2c1048c","dumps/main/attachments/search-config-icons/4e271681-3e0f-91ac-9750-03f665efc171.meta.json":"0a401871b82f1c1cbca91232fd643be1cc1a76c07a48830eaa2a47cdfafb1f14","dumps/main/attachments/search-config-icons/50f6171f-8e7a-b41b-862e-f97397038fb2":"9140bd1b30953f41bc758d2c0ecc873f5163e4f51126c278991eccd38589c541","dumps/main/attachments/search-config-icons/50f6171f-8e7a-b41b-862e-f97397038fb2.meta.json":"805d8ce33bac4611ce12d1f84ef431313555d76bf996264736e401ceb6dabe98","dumps/main/attachments/search-config-icons/5203dd03-2c55-4b53-9c60-58258d587be1":"adb29f6fd95956401630d94967381ac473f57215d96a5bcf500a00e747731380","dumps/main/attachments/search-config-icons/5203dd03-2c55-4b53-9c60-58258d587be1.meta.json":"27a6f994c2c7653a33d380ac13c4cfbc00f543a92f229426aa71d85b1f968357","dumps/main/attachments/search-config-icons/5914932e-66ba-4126-8be5-d37beadd9532":"02f54211387baa59e4246356dc7344e48f39a412f2e5993d7f403aa538df7276","dumps/main/attachments/search-config-icons/5914932e-66ba-4126-8be5-d37beadd9532.meta.json":"2df77daeeef5892fdb7fdeecffb804638bd0d2f7da5b9e617f01303d786dcd09","dumps/main/attachments/search-config-icons/5ded611d-44b2-dc46-fd67-fb116888d75d":"877fb3aca13d2a7c656df1f94df3fa052afbb40b65c99ba5382392ff5499016e","dumps/main/attachments/search-config-icons/5ded611d-44b2-dc46-fd67-fb116888d75d.meta.json":"d1c75915fdc86461e755cd08e670b01da41cd3d76688afe692f841733a9b7ee0","dumps/main/attachments/search-config-icons/5e03d6f4-6ee9-8bc8-cf22-7a5f2cf55c41":"9cd3da38e3938549434d1c3cba6fed249ffa7d91d9a6d7ffb5f4184f527cac76","dumps/main/attachments/search-config-icons/5e03d6f4-6ee9-8bc8-cf22-7a5f2cf55c41.meta.json":"8506d9438825f2dc34875e04e0212e22a2652c5c43aa93e4d184d59ec765316f","dumps/main/attachments/search-config-icons/6644f26f-28ea-4222-929d-5d43a02dae05":"4f1bfbfec1441bd9a304ca7f3b8fd54130e94df185f7b28bb17c86ba517e13b7","dumps/main/attachments/search-config-icons/6644f26f-28ea-4222-929d-5d43a02dae05.meta.json":"f7d37f9c8b87480539cd981f463790c99ed15b2ffc5e3ff4786dd11c25228df4","dumps/main/attachments/search-config-icons/6d10d702-7bd6-1452-90a5-3df665a38f66":"f895a965b68d02e7391cc4504d9be75e1ba7f9b50a1dd59af77bb44a7769c08c","dumps/main/attachments/search-config-icons/6d10d702-7bd6-1452-90a5-3df665a38f66.meta.json":"d782d80f8187cf8051be89c6b8a1ef4700e0b84dcda006843d1fd2f266c4419b","dumps/main/attachments/search-config-icons/6e36a151-e4f4-4117-9067-1ca82c47d01a":"e9849089ffced59563896974afee0fceedac7fc8455bbeaa5bae230f54c933d9","dumps/main/attachments/search-config-icons/6e36a151-e4f4-4117-9067-1ca82c47d01a.meta.json":"0e5a64c06ea0ae875e8e0fdc850feddf5a8714b8290293dcd100d455de32ace0","dumps/main/attachments/search-config-icons/6f4da442-d31e-28f8-03af-797d16bbdd27":"dd5cab3711f778677859e86000a127ed07a6175e8e58aecb0fba71b825ce76d7","dumps/main/attachments/search-config-icons/6f4da442-d31e-28f8-03af-797d16bbdd27.meta.json":"0a947797180fdaf031a9c2d2f841b88243c90ff85f0af873f99ddd770fc59e8b","dumps/main/attachments/search-config-icons/7072564d-a573-4750-bf33-f0a07631c9eb":"0a653ea57472694ac05623d9b237e479232a0d65683d05f89661f996054e3276","dumps/main/attachments/search-config-icons/7072564d-a573-4750-bf33-f0a07631c9eb.meta.json":"bb8a256f72b37166fea2ecd4c3a59f49615854a7210e6963f2571f8dcb3d3a3f","dumps/main/attachments/search-config-icons/70fdd651-6c50-b7bb-09ec-7e85da259173":"31a793dad95b5ffd02d39ebf14fc40877596f418f5926247487265034181dc8f","dumps/main/attachments/search-config-icons/70fdd651-6c50-b7bb-09ec-7e85da259173.meta.json":"8c744e9d2f218256e63f1b1a2193f2fc4a7b980e72464e8d57fbe150446f2efc","dumps/main/attachments/search-config-icons/71f41a0c-5b70-4116-b30f-e62089083522":"5aad083bfcef256d433c1ffa571b814d16f61832bcd7565bf03909011f6a0bfc","dumps/main/attachments/search-config-icons/71f41a0c-5b70-4116-b30f-e62089083522.meta.json":"4a8f0c4e4ee643faa2f8d8cc4ddb8f87d14c740e8c9252223f826181c0117741","dumps/main/attachments/search-config-icons/74793ce1-a918-a5eb-d3c0-2aadaff3c88c":"ca8f102ac4f35189ebcb786d080843b603b234f89b8d8b1c0ef27a0ab7148182","dumps/main/attachments/search-config-icons/74793ce1-a918-a5eb-d3c0-2aadaff3c88c.meta.json":"60a7975cd79156623b0ca58be4110d152e50b6e9caaaa211dad1cd37eabb0345","dumps/main/attachments/search-config-icons/74f94dc2-caf6-4b90-b3d2-f3e2f7714d88":"3376e14529ed2e96c7dc491b3bf11914d7c8ff47a068311b2432c086c2ae0f28","dumps/main/attachments/search-config-icons/74f94dc2-caf6-4b90-b3d2-f3e2f7714d88.meta.json":"3a94a78a846f312c85c0609971b153aaba9819e2b657f25e3b0648a3956933d1","dumps/main/attachments/search-config-icons/764e3b14-fe16-4feb-8384-124c516a5afa":"71413ef23ac14ce2b7bb76f7f5d16b2df267239841a88ddab36b129481e00616","dumps/main/attachments/search-config-icons/764e3b14-fe16-4feb-8384-124c516a5afa.meta.json":"2f16dd51ade97a327d4e5f14d689f822a5c9061b9b27810bbccbf2f406a5e56f","dumps/main/attachments/search-config-icons/7bbe6c5c-fdb8-2845-a4f4-e1382e708a0e":"24daa27a3234d01b5add42e027b0a34000d0ab47c17fe3924c2ca267b7b61c19","dumps/main/attachments/search-config-icons/7bbe6c5c-fdb8-2845-a4f4-e1382e708a0e.meta.json":"308d345dbcfd7583e5f7460d34caf3b63d01b747a6e060a2b0971bf00ed2b22c","dumps/main/attachments/search-config-icons/7bf4ca37-e2b8-4d31-a1c3-979bc0e85131":"912d20feefcba57d43bffff5e245b8c1e3865155ed686d8ad253bbab71116e83","dumps/main/attachments/search-config-icons/7bf4ca37-e2b8-4d31-a1c3-979bc0e85131.meta.json":"3ec071b0a2940cd8892a72bd28d44237aecfd20d88303661348257ddb98aee43","dumps/main/attachments/search-config-icons/7c81cf98-7c11-4afd-8279-db89118a6dfb":"e988445d87afe0d285bea251705fc23eb70ac42426ab0d7a69d9276585c5573c","dumps/main/attachments/search-config-icons/7c81cf98-7c11-4afd-8279-db89118a6dfb.meta.json":"273dd09cad2a62459cc062e3b39b835d55a06b10cb7d5149aad77dd55451821f","dumps/main/attachments/search-config-icons/7cb4d88a-d4df-45b2-87e4-f896eaf1bbdb":"8dc2e75e6792b8374b20621fa2151ac24b4626e5c1f6a1abec4f912746441859","dumps/main/attachments/search-config-icons/7cb4d88a-d4df-45b2-87e4-f896eaf1bbdb.meta.json":"21d2522ab4e47477e72da3a2d2223e50e55fef442e2ba736d56df1e09593d76f","dumps/main/attachments/search-config-icons/7edaf4fe-a8a0-432b-86d2-bf75ebe80851":"27541cb376bdda829a6cf9cefd13da112728881e3daa4ac3c1178d4ce15f1e8b","dumps/main/attachments/search-config-icons/7edaf4fe-a8a0-432b-86d2-bf75ebe80851.meta.json":"3aea5d0652172940ac33e32628dcc6a03b79fe686c6de752482c8e3ae5cd70eb","dumps/main/attachments/search-config-icons/7efbed51-813c-581d-d8d3-f8758434e451":"b0c6d1850265e3c946917232ca6c6ace3dad23347bfab4f81351eac569326d34","dumps/main/attachments/search-config-icons/7efbed51-813c-581d-d8d3-f8758434e451.meta.json":"5a723c8f04bffa33a69a7054d30a4816caf1a3924081c85e1d9770126f761a96","dumps/main/attachments/search-config-icons/84bb4962-e571-227a-9ef6-2ac5f2aac361":"a1fd5d127a5f2590ddcd439b7a2abb3456b48217ea11daf0345b26e108f520e6","dumps/main/attachments/search-config-icons/84bb4962-e571-227a-9ef6-2ac5f2aac361.meta.json":"5cb0ebdde367b9754ddf6cbd01150414d27977b2d4c5f65cd6bbb89989388f3b","dumps/main/attachments/search-config-icons/87ac4cde-f581-398b-1e32-eb4079183b36":"33ca72f1eac56793d1fd811189cedef98004a067c85b1143083b564814a4b0db","dumps/main/attachments/search-config-icons/87ac4cde-f581-398b-1e32-eb4079183b36.meta.json":"d97eca8063cc17b99c81c55d4ff121d765c793e006ed252fec5f9539bd0fc339","dumps/main/attachments/search-config-icons/8831ce10-b1e4-6eb4-4975-83c67457288e":"ca3cc8786977f6ffeb0546ff8f3bb2b7fd240d1956fbf86777dbf0e8bec9c03b","dumps/main/attachments/search-config-icons/8831ce10-b1e4-6eb4-4975-83c67457288e.meta.json":"45274d848d1f6d398563bb46a2bfa3eee40ff16a5dbf0bbc8904db442f80702c","dumps/main/attachments/search-config-icons/890de5c4-0941-a116-473a-5d240e79497a":"6ba1f0fd1d12014cab32f74daab24dfa16fb26613ace20a1e595267621038a07","dumps/main/attachments/search-config-icons/890de5c4-0941-a116-473a-5d240e79497a.meta.json":"107547059360c3658dcf187a546ffb52bb23fa385e1338151043bebe82bbf640","dumps/main/attachments/search-config-icons/8abb10a7-212f-46b5-a7b4-244f414e3810":"f8780adb4d7b28f2f881db4ca7b697d8fc916cd9fa834ccc445fe7d4b72a6cc7","dumps/main/attachments/search-config-icons/8abb10a7-212f-46b5-a7b4-244f414e3810.meta.json":"5401603c7abbc6ca5bdddb8f9cca7eee2e26e5721cc73f23d95f600d5421d431","dumps/main/attachments/search-config-icons/91a9672d-e945-8e1e-0996-aefdb0190716":"5d53ef1866a08cc29011f5f2a9ce99bbf37cf42e80de7f0e8cc30d13337e8187","dumps/main/attachments/search-config-icons/91a9672d-e945-8e1e-0996-aefdb0190716.meta.json":"4e8ea36e3d659eb22ac7c86498003ca8885bab9c40685bb8ca7796a8230201da","dumps/main/attachments/search-config-icons/94a84724-c30f-4767-ba42-01cc37fc31a4":"98dca7e24cad0a1be96ef2c323e9759beb63c72440756f887e2482d9ce8e8969","dumps/main/attachments/search-config-icons/94a84724-c30f-4767-ba42-01cc37fc31a4.meta.json":"1070966901fe9db82b71bfa74ddeedd4f23ab2ed1eddaf201634e06a604e6006","dumps/main/attachments/search-config-icons/95ed201d-4ab8-4cb8-831d-454f53cab0f8":"3426b5100a6bdb45f8039f0c71a6b68193750ba7bae5b36e5ed31b2b7f372cda","dumps/main/attachments/search-config-icons/95ed201d-4ab8-4cb8-831d-454f53cab0f8.meta.json":"3447cd050619c1d2e5859147ab894a43da75235a580219306d8629e28a7a3eb5","dumps/main/attachments/search-config-icons/96327a73-c433-5eb4-a16d-b090cadfb80b":"ca6e972004f62355c1ea97656bc2328e1643971bdecab9c6b563d45593b8122e","dumps/main/attachments/search-config-icons/96327a73-c433-5eb4-a16d-b090cadfb80b.meta.json":"c4e3c9e6426e6f35410c287eef95b3e2134e54409e462f02dd440876c06b1bb4","dumps/main/attachments/search-config-icons/9802e63d-05ec-48ba-93f9-746e0981ad98":"6b1b073183eb0012daea0dce351a94d395c8a0b531b610e56eac52b3d1d1da0e","dumps/main/attachments/search-config-icons/9802e63d-05ec-48ba-93f9-746e0981ad98.meta.json":"cceb55c68db8dddd23d064364a281e982069bfe2bb55eba7d282fffcec2aa89f","dumps/main/attachments/search-config-icons/9d96547d-7575-49ca-8908-1e046b8ea90e":"6a743574353de0ec7c85b49f46b2b554caa0fc1d064b90544c5dea0fea2b8901","dumps/main/attachments/search-config-icons/9d96547d-7575-49ca-8908-1e046b8ea90e.meta.json":"10897754c5aafe0b84413afee5e9948fd799262a26aa07bca85fe6fb369beac4","dumps/main/attachments/search-config-icons/a06db97d-1210-ea2e-5474-0e2f7d295bfd":"617dec5d635efb0a12d0de935c6999ef0249f4a63c62bdcb96551518bc3d1812","dumps/main/attachments/search-config-icons/a06db97d-1210-ea2e-5474-0e2f7d295bfd.meta.json":"06cf576ca882bd7c2d54c18329e21e5b1a9cb7732d4954b52cbfa52979a67765","dumps/main/attachments/search-config-icons/a06dc3fd-4bdb-41f3-2ebc-4cbed06a9bd3":"d994f806b1e4225b50be5ab681b2cecf845cc216a19a432d878cea3cb815bafd","dumps/main/attachments/search-config-icons/a06dc3fd-4bdb-41f3-2ebc-4cbed06a9bd3.meta.json":"67524e18799023a017c7d9db1b9ba5c9cc3090d20f8154449a8f44ba22719104","dumps/main/attachments/search-config-icons/a2c7d4e9-f770-51e1-0963-3c2c8401631d":"1bf68aca7bfc75ca8485c3dac9a1daa13c1a3eb480688c32262096af6076adfa","dumps/main/attachments/search-config-icons/a2c7d4e9-f770-51e1-0963-3c2c8401631d.meta.json":"4ab103bba0f8fde581c3950c6c08cfcf6786104d8cbcba240499308f26958d04","dumps/main/attachments/search-config-icons/a83f24e4-602c-47bd-930c-ad0947ee1adf":"66612f999921d892645c8a2b37aa5dad17b134e7fdaed375a683baec7fc10697","dumps/main/attachments/search-config-icons/a83f24e4-602c-47bd-930c-ad0947ee1adf.meta.json":"f985ffbde6cf6ef972b6798c9336922dcfa29ca9a31e3aa4fae1962e069bdb0c","dumps/main/attachments/search-config-icons/b64f09fd-52d1-c48e-af23-4ce918e7bf3b":"c3e8300801c5c585662f14fd8e819d635efd9830783dc3c631212927866e9898","dumps/main/attachments/search-config-icons/b64f09fd-52d1-c48e-af23-4ce918e7bf3b.meta.json":"f7fd846d6717131e75865f8f5ed562e88f40be3dcf1603f2660b425dedabc7d1","dumps/main/attachments/search-config-icons/b882b24d-1776-4ef9-9016-0bdbd935eda3":"076352591c7077af4af5771918f80b5da9c6bf479327cc68390abdb158f3ec03","dumps/main/attachments/search-config-icons/b882b24d-1776-4ef9-9016-0bdbd935eda3.meta.json":"229139bca53bc63bd59b8f261f36c11fbe76b2b45dfeac2580261cf290c41365","dumps/main/attachments/search-config-icons/b8ca5a94-8fff-27ad-6e00-96e244a32e21":"1474c93e49c209aca2a2df2acb61b64574805106bead6edebd67287de21920e0","dumps/main/attachments/search-config-icons/b8ca5a94-8fff-27ad-6e00-96e244a32e21.meta.json":"6fd72c11afb4249d0166d8d98c552ee02d73c0e07f0578bfd3d7e67d70bcaee3","dumps/main/attachments/search-config-icons/b9424309-f601-4a69-98ca-ca68e65633e6":"601d72e7abde5ec864b3d8ca0031896f769107670b84c66053062481a56d8665","dumps/main/attachments/search-config-icons/b9424309-f601-4a69-98ca-ca68e65633e6.meta.json":"f299a7d56c5552fc592c66073d3e1e1d16ce4a99e935dcc0cad7dafcad6b9e3b","dumps/main/attachments/search-config-icons/c411adc1-9661-4fb5-a4c1-8cfe74911943":"150765e8e9b985ba5b820ac9b8e7623023d5a0e24f94663d5e9203d8d7598059","dumps/main/attachments/search-config-icons/c411adc1-9661-4fb5-a4c1-8cfe74911943.meta.json":"c5cc89d5f24ef1fa40b1c47c2e97eaeb01439b8d3b186b9c2fe716c94ead30f2","dumps/main/attachments/search-config-icons/cbf9e891-d079-2b28-5617-283450d463dd":"5b2c34b3c4e8dd898b664dba6c3786e2ff9869eff55d673aa48361f11325ed07","dumps/main/attachments/search-config-icons/cbf9e891-d079-2b28-5617-283450d463dd.meta.json":"b757806fd1b922d81bbecab94c73d3db98cfc2aa2791a4d5137112f795a732ee","dumps/main/attachments/search-config-icons/d87f251c-3e12-a8bf-e2d0-afd43d36c5f9":"865d76c8175a8f11dedc93f0bc212242a97a8a76adac870e8249368cecc81402","dumps/main/attachments/search-config-icons/d87f251c-3e12-a8bf-e2d0-afd43d36c5f9.meta.json":"22594c8870cbabe5fc5d2637509235202502661b466e9e37c5878716f323a34f","dumps/main/attachments/search-config-icons/db0e1627-ae89-4c25-8944-a9481d8512d9":"97a68f0b948b68bbf389a9ef43e2fe6c31ff8dc7889c939fdfdea79378576c67","dumps/main/attachments/search-config-icons/db0e1627-ae89-4c25-8944-a9481d8512d9.meta.json":"1eccc999dcd377af84cf63ed60b7ef23d5d4b936a1e465d12349a5366b1b012d","dumps/main/attachments/search-config-icons/e02f23df-8d48-2b1b-3b5c-6dd27302c61c":"247aa26993083705ce99a8e5612cdf262aca98cde86ba19afc964329ba95986a","dumps/main/attachments/search-config-icons/e02f23df-8d48-2b1b-3b5c-6dd27302c61c.meta.json":"06fc893d29cf406519611da9d1993a13bd9134192940c12bf64536ea571db4f0","dumps/main/attachments/search-config-icons/e718e983-09aa-e8f6-b25f-cd4b395d4785":"809697f48848e7c3638d5f3e0b224ea60b3800504e7bd8417854d55989b85196","dumps/main/attachments/search-config-icons/e718e983-09aa-e8f6-b25f-cd4b395d4785.meta.json":"0d9baef39747776500e5b83e72cd9d901fc09ac08247368dd2117bb4ec011f54","dumps/main/attachments/search-config-icons/e7547f62-187b-b641-d462-e54a3f813d9a":"c971ee33b8c0a57349669d957bf73070b0632b128c94748e845b57d5e15221a4","dumps/main/attachments/search-config-icons/e7547f62-187b-b641-d462-e54a3f813d9a.meta.json":"8ec4f6a7826966f2ff82632ef527366db3452ebc40c90a557602111f0ea956c9","dumps/main/attachments/search-config-icons/eb62e768-151b-45d1-9fe5-9e1d2a5991c5":"aa46b3d1ed8557e5bc7e71988cc6c46b00363b890d2a781973f9dc9073f8dd31","dumps/main/attachments/search-config-icons/eb62e768-151b-45d1-9fe5-9e1d2a5991c5.meta.json":"a06682b589df8dd63b1f25c01630ead55a89217f72c0bc04b391829af3fef59f","dumps/main/attachments/search-config-icons/f312610a-ebfb-a106-ea92-fd643c5d3636":"91d17ba44192a6430ffdb447ff3a11533ef964628f67c13480cc9470212d3d65","dumps/main/attachments/search-config-icons/f312610a-ebfb-a106-ea92-fd643c5d3636.meta.json":"ce26ab2382a7a67a55688330dd74127b4a980610f4030bde8eaaa20b81306559","dumps/main/attachments/search-config-icons/fa0fc42c-d91d-fca7-34eb-806ff46062dc":"6da5620880159634213e197fafca1dde0272153be3e4590818533fab8d040770","dumps/main/attachments/search-config-icons/fa0fc42c-d91d-fca7-34eb-806ff46062dc.meta.json":"0c3c0eb832be884f25186395b8bf08cdbe0a6e2845b9e55e7cbea5d0f183ed7d","dumps/main/attachments/search-config-icons/fca3e3ee-56cd-f474-dc31-307fd24a891d":"c4d88cfa5262f6d2cf76b167281d25821c9e1770684b739ed6ad3cf7277a121b","dumps/main/attachments/search-config-icons/fca3e3ee-56cd-f474-dc31-307fd24a891d.meta.json":"a40c37a5150e3745849f67305fe2fe1e06ef1c3901f6dc604a8e3f6c94e7b624","dumps/main/attachments/search-config-icons/fe75ce3f-1545-400c-b28c-ad771054e69f":"3a9d06951c7c9d2c19cd00533a760b0f8755b1e2e718af81c710297d030fbe44","dumps/main/attachments/search-config-icons/fe75ce3f-1545-400c-b28c-ad771054e69f.meta.json":"3f353e083d7a885f6d59d36c9276a2d325686a533cf8c502cd41a10172e763ea","dumps/main/attachments/search-config-icons/fed4f021-ff3e-942a-010e-afa43fda2136":"d7fdfd971d874f2ec6f209df6f6b8173d126cd3f7a25daacb94de4259efbcf16","dumps/main/attachments/search-config-icons/fed4f021-ff3e-942a-010e-afa43fda2136.meta.json":"740f77dcc93ece89fd55557baf399a4464373c81154b0a9758b8622f6c458253","dumps/main/regions.json":"e8990158373f82d3f89fed5089cf29e4177cc85904479128728e05025e9a0c0c","dumps/main/search-config-icons.json":"8bfa7c4abd2ab4238cd2ea66dc143bb9048f2699735b01560980109dbe39d759","dumps/main/search-config-v2.json":"b3ae5079d9162a68b05893bd350f7456a0babe8bd72ad0c2b7f52a5b6591d3b1","dumps/main/search-telemetry-v2.json":"405b6a0e198f5cc2d2a4e484a5ccd2ca269bd5e08d03857cdc8e102c35f58708","dumps/main/summarizer-models-config.json":"2785f498567aebcc2c3157b360a06970b8174815506a6e018c4cf9130d150002","src/cache.rs":"c6179802017b43885136e7d64004890cc13e8c2d4742e04073cf404b578f63db","src/client.rs":"c3e54387ebaef56508a0fb66cf891e0c245cd1a0e6e03047cde05b7f6eddee54","src/config.rs":"3e322bdab94855e17427187ffe92a59c1a64c9175d5e1f8605df2f6409a3c93f","src/context.rs":"43bab81026b6f1a2509d129e806fffd09ba80110d656798a02589985017a3c21","src/error.rs":"7f56c3ae167811c5a8413b73a7e6abcec2377c67cf48e7520929e15532678eef","src/jexl_filter.rs":"48a9d960e05dae444421f7c4ceeb45eab656f03f1e7071215c8e8d39aab56b54","src/lib.rs":"cd7d816f87146693471c328a185747e3b786a51f3ddbb780a71f244f18179526","src/macros.rs":"6b06d0ba42ee95235bfd71bac1a0eed02f60c894775ebee64165648b10e932c4","src/schema.rs":"348e0d5ad1840aaae796b537d21381ef91bd75be262138bfec376d9f88d205b3","src/service.rs":"3f0757473194d30d7fb5be75dfe9647640e9d23253f4167139e8bd70468e9abd","src/signatures.rs":"baa2dae76abd8166158fea4676e67e17c17b65af6968de52768350409dbd7092","src/storage.rs":"c33dd92914770e96d3d44dbb9e95f512ce54261710a42c7cf4a896be348c529e","uniffi.toml":"bd7cc0e7c1981f53938f429c4f2541ac454ed4160a8a0b4670659e38acd23ee5"},"package":null}
+\ No newline at end of file
diff --git a/third_party/rust/remote_settings/dumps/main/search-config-v2.json b/third_party/rust/remote_settings/dumps/main/search-config-v2.json
@@ -2568,8 +2568,8 @@
                 "value": "firefox"
               },
               {
-                "experimentConfig": "search_rich_suggestions",
-                "name": "channel"
+                "name": "channel",
+                "value": "fen"
               }
             ],
             "searchTermParamName": "q"
@@ -2588,14 +2588,36 @@
               }
             ],
             "searchTermParamName": "q"
+          },
+          "visualSearch": {
+            "acceptedContentTypes": [
+              "image/jpeg",
+              "image/gif",
+              "image/png",
+              "image/avif",
+              "image/webp"
+            ],
+            "base": "https://lens.google.com/upload",
+            "displayNameMap": {
+              "default": "Google Lens"
+            },
+            "excludePartnerCodeFromTelemetry": true,
+            "isNewUntil": "2025-12-01",
+            "params": [
+              {
+                "name": "ep",
+                "value": "fcm"
+              }
+            ],
+            "searchTermParamName": "url"
           }
         }
       },
       "id": "7ace4aa1-e762-4f4b-87b9-b23b3c3a930b",
       "identifier": "google",
-      "last_modified": 1753192235006,
+      "last_modified": 1761573989454,
       "recordType": "engine",
-      "schema": 1753191541223,
+      "schema": 1761358547622,
       "variants": [
         {
           "environment": {
@@ -3430,37 +3452,37 @@
           "suggestions": {
             "base": "https://suggest.perplexity.ai/suggest",
             "searchTermParamName": "q"
-          },
-          "trending": {
-            "base": "https://www.perplexity.ai/rest/autosuggest/list-trending-suggest"
           }
         }
       },
       "id": "bb836721-7be9-4de6-ac18-520189a69076",
       "identifier": "perplexity",
-      "last_modified": 1749848937099,
+      "last_modified": 1760466845276,
       "recordType": "engine",
-      "schema": 1749743664865,
+      "schema": 1760449157753,
       "variants": [
         {
           "environment": {
-            "experiment": "perplexity"
+            "allRegionsAndLocales": true,
+            "applications": [
+              "firefox"
+            ]
           },
+          "isNewUntil": "2025-10-21",
           "subVariants": [
             {
               "environment": {
-                "locales": [
-                  "de"
-                ],
-                "regions": [
-                  "de",
-                  "us",
-                  "gb"
-                ]
+                "minVersion": "143.0a1"
               },
               "urls": {
                 "trending": {
-                  "base": "https://www.perplexity.ai/rest/autosuggest/list-trending-suggest?lang=de-DE"
+                  "base": "https://www.perplexity.ai/rest/autosuggest/list-trending-suggest",
+                  "params": [
+                    {
+                      "name": "lang",
+                      "value": "{acceptLanguages}"
+                    }
+                  ]
                 }
               }
             }
@@ -8400,5 +8422,5 @@
       "schema": 1707824831520
     }
   ],
-  "timestamp": 1753710379308
+  "timestamp": 1761573989454
 }
 \ No newline at end of file
diff --git a/third_party/rust/remote_settings/dumps/main/search-telemetry-v2.json b/third_party/rust/remote_settings/dumps/main/search-telemetry-v2.json
@@ -93,19 +93,72 @@
       "followOnParamNames": [],
       "id": "19c434a3-d173-4871-9743-290ac92a3f6b",
       "isSPA": true,
-      "last_modified": 1741781945960,
+      "last_modified": 1757010621729,
       "organicCodes": [],
+      "pageTypeParam": {
+        "enableSPAHandling": true,
+        "keys": [
+          "t"
+        ],
+        "pageTypes": [
+          {
+            "enabled": true,
+            "isDefault": true,
+            "name": "web",
+            "target": "default_tab",
+            "values": [
+              "web"
+            ]
+          },
+          {
+            "enabled": false,
+            "name": "images",
+            "values": [
+              "images"
+            ]
+          },
+          {
+            "enabled": false,
+            "name": "videos",
+            "values": [
+              "videos"
+            ]
+          },
+          {
+            "enabled": false,
+            "name": "news",
+            "values": [
+              "news"
+            ]
+          },
+          {
+            "enabled": true,
+            "name": "shopping",
+            "target": "shopping_tab",
+            "values": [
+              "shopping"
+            ]
+          }
+        ]
+      },
       "queryParamName": "q",
       "queryParamNames": [
         "q"
       ],
-      "schema": 1741189704472,
+      "schema": 1756952145762,
       "searchPageMatches": [
         "https://www.qwant.com/*"
       ],
       "searchPageRegexp": "^https://www\\.qwant\\.com/",
+      "shoppingTab": {
+        "inspectRegexpInSERP": true,
+        "regexp": "t=shopping",
+        "selector": "[data-testid='shoppingNavItem']"
+      },
       "subframes": [],
       "taggedCodes": [
+        "ff_android",
+        "ff_ios",
         "brz-moz",
         "firefoxqwant"
       ],
@@ -346,7 +399,7 @@
       "ignoreLinkRegexps": [
         "^https?://consent\\.google\\.(?:.+)/d\\?continue\\="
       ],
-      "last_modified": 1753192248302,
+      "last_modified": 1754960964129,
       "nonAdsLinkQueryParamNames": [
         "url"
       ],
@@ -356,9 +409,13 @@
       "organicCodes": [],
       "queryParamName": "q",
       "queryParamNames": [
-        "q"
+        "q",
+        "lns_mode"
       ],
-      "schema": 1753150537617,
+      "schema": 1754878540963,
+      "searchMode": {
+        "lns_mode": "image_search"
+      },
       "searchPageMatches": [
         "https://{host}/search*"
       ],
@@ -405,6 +462,7 @@
         "firefox-b-pn-wt",
         "firefox-b-pn-wt-us",
         "firefox-b-vv",
+        "lens-firefox-fcm",
         "ubuntu",
         "ubuntu-sn"
       ],
@@ -918,5 +976,5 @@
       "telemetryId": "bing"
     }
   ],
-  "timestamp": 1753289524079
+  "timestamp": 1757010621729
 }
 \ No newline at end of file
diff --git a/third_party/rust/remote_settings/dumps/main/summarizer-models-config.json b/third_party/rust/remote_settings/dumps/main/summarizer-models-config.json
@@ -1,20 +1,21 @@
 {
   "data": [
     {
-      "id": "44eaaf7f-a481-4adf-b6d6-c42556afea41",
-      "instructions": "You are an expert at creating mobile-optimized summaries. Process: Step 1: Identify the type of content. Step 2: Based on content type, prioritize: Recipe - Servings, Total time, Ingredients list, Key steps, Tips. News - What happened, when, where. How-to - Total time, Materials, Key steps, Warnings. Review - Bottom line rating, price. Opinion - Main arguments, Key evidence. Personal Blog - Author, main points. Fiction - Author, summary of plot. All other content types - Provide a brief summary of no more than 6 sentences. Step 3: Format for mobile using concise language and paragraphs with 3 sentences maximum. Bold critical details (numbers, warnings, key terms). Do not include any introductions, follow-ups, questions, or closing statements.",
-      "last_modified": 1754918378407,
-      "name": "appleSummarizer",
-      "schema": 1754918225127
+      "config": "{\"temperature\":0.1}",
+      "id": "a55e4423-56ee-489b-814d-e58929175eff",
+      "instructions": "You are a Content Summarizer. You create mobile-optimized summaries by first understanding what users actually need from each type of content. Process: Step 1: Identify and Adapt. Use tree of thought to determine: What type of content is this? What would a mobile user want to extract? What is the most valuable information to lead with? Step 2: Extract Core Value. Based on content type, prioritize: Recipe - Ingredients (transcribe exactly), key steps, time, pro tips. News - What happened, when, impact on reader. How-to - Requirements, main steps, warnings, outcome. Review - Bottom line rating, pros/cons, price, target audience. Research - Key finding, confidence level, real-world meaning. Opinion - Main argument and key evidence. Step 3: Mobile Format. Never include an overall title/header for the summary. Keep section labels. Start immediately with the core content. Lead with the most actionable/important info. Use short paragraphs (2-3 sentences max). Bold only critical details (numbers, warnings, key terms). Always start with the content, not metadata, header, or titles. Quality Test: Ask ‘If someone only read the first 30 words, would they get value?’ Examples: Recipe Format: Ingredients: (transcribe exactly), numbered essential steps only, total time, most important advice. News Format: What happened (core event), Why it matters (impact on reader), Key details (when, who, numbers). Adapt the format to serve the user’s actual need from that content type. Never include the title or header of the summary.",
+      "last_modified": 1755604678567,
+      "name": "appleSummarizer-generic",
+      "schema": 1755566851238
     },
     {
       "config": "{\"top_p\":0.01,\"temperature\":0.1}",
-      "id": "d8cfe50d-9cb8-4ad3-a5dc-23991a3ffd48",
-      "instructions": "You are an expert at creating mobile-optimized summaries. Process: Step 1: Identify the type of content. Step 2: Based on content type, prioritize: Recipe - Servings, Total time, Ingredients list, Key steps, Tips. News - What happened, when, where. How-to - Total time, Materials, Key steps, Warnings. Review - Bottom line rating, price. Opinion - Main arguments, Key evidence. Personal Blog - Author, main points. Fiction - Author, summary of plot. All other content types - Provide a brief summary of no more than 6 sentences. Step 3: Format for mobile using concise language and paragraphs with 3 sentences maximum. Bold critical details (numbers, warnings, key terms).",
-      "last_modified": 1754929064672,
-      "name": "liteLLMSummarizer",
-      "schema": 1754918378465
+      "id": "b68e2425-ebc6-4b07-bb1c-78c7363ea7a8",
+      "instructions": "You are a Content Summarizer. You create mobile-optimized summaries by first understanding what users actually need from each type of content. Process: Step 1: Identify and Adapt. Use tree of thought to determine: What type of content is this? What would a mobile user want to extract? What is the most valuable information to lead with? Step 2: Extract Core Value. Based on content type, prioritize: Recipe - Ingredients (transcribe exactly), key steps, time, pro tips. News - What happened, when, impact on reader. How-to - Requirements, main steps, warnings, outcome. Review - Bottom line rating, pros/cons, price, target audience. Research - Key finding, confidence level, real-world meaning. Opinion - Main argument and key evidence. Step 3: Mobile Format. Never include an overall title/header for the summary. Keep section labels. Start immediately with the core content. Lead with the most actionable/important info. Use short paragraphs (2-3 sentences max). Bold only critical details (numbers, warnings, key terms). Always start with the content, not metadata, header, or titles. Quality Test: Ask ‘If someone only read the first 30 words, would they get value?’ Examples: Recipe Format: Ingredients: (transcribe exactly), numbered essential steps only, total time, most important advice. News Format: What happened (core event), Why it matters (impact on reader), Key details (when, who, numbers). Adapt the format to serve the user’s actual need from that content type. Never include the title or header of the summary.",
+      "last_modified": 1755604678564,
+      "name": "liteLLMSummarizer-generic",
+      "schema": 1755566850901
     }
   ],
-  "timestamp": 1754929064672
+  "timestamp": 1755604678567
 }
 \ No newline at end of file
diff --git a/third_party/rust/suggest/.cargo-checksum.json b/third_party/rust/suggest/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"fa463a586e90c448902f714a6f8e3b84dde36b0687a8fd5a9fdaf730280d82cd","README.md":"60e4f7ca928dd739768925ff26eada1907509b3e48dfd369a00845bc7eac1653","metrics.yaml":"5df9ca1a3415d9a796ccc8dba8e3126cbcc338f7792b0053030e3b5399470149","src/benchmarks/README.md":"ccee8dbddba8762d0453fa855bd6984137b224b8c019f3dd8e86a3c303f51d71","src/benchmarks/client.rs":"e5897d4e2eda06809fa6dc6db4e780b9ef266f613fb113aa6613b83f7005dd0b","src/benchmarks/geoname.rs":"fb4e8eb48e27879fe3f35d6d2415f0237b087b51b89ee03fb50fa635e1c1a3b5","src/benchmarks/ingest.rs":"3e0dc8239452b449df79100bfe21fbfae85f6c55b6bc17336e9f86000a7b4042","src/benchmarks/mod.rs":"2c9a39b7a5144674d2475f4d7d69d77c4545f9aa5f123968cb32574e76f10b1a","src/benchmarks/query.rs":"d54946063e72cf98e7f46d94665c17c66af637774c2bb50cd5798dbe63d74f3c","src/config.rs":"0ca876e845841bb6429862c0904c82265003f53b55aea053fac60aed278586a7","src/db.rs":"2b2995a93b7175e3519134314dbeda51832745ee33c456b5bae50f9e478dbcaa","src/error.rs":"e2ef3ec0e0b2b8ecbb8f2f1717d4cb753af06913b8395d086b7643098ad100a7","src/fakespot.rs":"f501c9fe5296e7c130a9fcb532b861465717652cb5ef688230bc7a3b94df91b1","src/geoname.rs":"adbf29aab9031c2d09242dfcbf351c139b8bb792fa42ed72ef33082c920f69e8","src/lib.rs":"772dfc3625c0733dde442a5e10020d53e54fc86e39c37ce43e84dfb79a534936","src/metrics.rs":"871f0d834efbbc9e26d61f66fa31f0021dcf41444746cd7c082f93ba9628e399","src/provider.rs":"dbf7a0da37f7022c6606c06356ce152b44f799dabd6a6ee734dba426c1d96386","src/query.rs":"d4eeaf43251c8e6404ac75570ed069085c7e3f61be887ab8d127b08c106198c5","src/rs.rs":"60bc209657820050151c7025f14055f6bc56b889ac16fc827bd4697a3033f3f6","src/schema.rs":"490f7544b45361807fb7fe3d213e1827ef0b4f588c2b35fad46eb4478d6a8c5a","src/store.rs":"c0825ef4c5736a7a843a63654032a434bd40255a49849857278c6f6a082fed49","src/suggestion.rs":"d97050db6df628da09a8f481a4e650b17ce916f3cd88118c6571d2883d36b964","src/testing/client.rs":"47a32fd84c733001f11e8bfff94dc8c060b6b0780346dca5ddc7a5f5489c1d85","src/testing/data.rs":"4f79c37eb026b02d60fdbcfa871df4e25589d2cd8153753ae0a3f05333ce4423","src/testing/mod.rs":"7b4a507aceb159347843ba09461e0d58962027ba5dcd35aa4b993fe3666508ce","src/util.rs":"4402f93a579ed0e321501abec4f74549092fb84aff21a17a4a971db0db87180f","src/weather.rs":"d7b747a32549d5200f19b2ba851cda84086b8a8f4ee7affe90e95920b22274f2","src/yelp.rs":"1fe3b7eb6b3f7462e9758b6eb62457dfa26f7549a8290cdff7637d2fb3ffea4f","uniffi.toml":"8205e4679ac26d53e70af0f85c013fd27cda1119f4322aebf5f2b9403d45a611"},"package":null}
-\ No newline at end of file
+{"files":{"Cargo.toml":"be816b0197a9cd45c0592d1bb2463b708175207cac044b6256c867743387875a","README.md":"60e4f7ca928dd739768925ff26eada1907509b3e48dfd369a00845bc7eac1653","metrics.yaml":"5df9ca1a3415d9a796ccc8dba8e3126cbcc338f7792b0053030e3b5399470149","src/benchmarks/README.md":"ccee8dbddba8762d0453fa855bd6984137b224b8c019f3dd8e86a3c303f51d71","src/benchmarks/client.rs":"e5897d4e2eda06809fa6dc6db4e780b9ef266f613fb113aa6613b83f7005dd0b","src/benchmarks/geoname.rs":"fb4e8eb48e27879fe3f35d6d2415f0237b087b51b89ee03fb50fa635e1c1a3b5","src/benchmarks/ingest.rs":"3e0dc8239452b449df79100bfe21fbfae85f6c55b6bc17336e9f86000a7b4042","src/benchmarks/mod.rs":"2c9a39b7a5144674d2475f4d7d69d77c4545f9aa5f123968cb32574e76f10b1a","src/benchmarks/query.rs":"d54946063e72cf98e7f46d94665c17c66af637774c2bb50cd5798dbe63d74f3c","src/config.rs":"0ca876e845841bb6429862c0904c82265003f53b55aea053fac60aed278586a7","src/db.rs":"2b2995a93b7175e3519134314dbeda51832745ee33c456b5bae50f9e478dbcaa","src/error.rs":"e2ef3ec0e0b2b8ecbb8f2f1717d4cb753af06913b8395d086b7643098ad100a7","src/fakespot.rs":"f501c9fe5296e7c130a9fcb532b861465717652cb5ef688230bc7a3b94df91b1","src/geoname.rs":"adbf29aab9031c2d09242dfcbf351c139b8bb792fa42ed72ef33082c920f69e8","src/lib.rs":"772dfc3625c0733dde442a5e10020d53e54fc86e39c37ce43e84dfb79a534936","src/metrics.rs":"871f0d834efbbc9e26d61f66fa31f0021dcf41444746cd7c082f93ba9628e399","src/provider.rs":"dbf7a0da37f7022c6606c06356ce152b44f799dabd6a6ee734dba426c1d96386","src/query.rs":"d4eeaf43251c8e6404ac75570ed069085c7e3f61be887ab8d127b08c106198c5","src/rs.rs":"60bc209657820050151c7025f14055f6bc56b889ac16fc827bd4697a3033f3f6","src/schema.rs":"490f7544b45361807fb7fe3d213e1827ef0b4f588c2b35fad46eb4478d6a8c5a","src/store.rs":"c0825ef4c5736a7a843a63654032a434bd40255a49849857278c6f6a082fed49","src/suggestion.rs":"d97050db6df628da09a8f481a4e650b17ce916f3cd88118c6571d2883d36b964","src/testing/client.rs":"47a32fd84c733001f11e8bfff94dc8c060b6b0780346dca5ddc7a5f5489c1d85","src/testing/data.rs":"4f79c37eb026b02d60fdbcfa871df4e25589d2cd8153753ae0a3f05333ce4423","src/testing/mod.rs":"7b4a507aceb159347843ba09461e0d58962027ba5dcd35aa4b993fe3666508ce","src/util.rs":"22091900a1f83babe126d86da10388f9d4d22b34dd1e67afdd868fedeb460c2b","src/weather.rs":"d7b747a32549d5200f19b2ba851cda84086b8a8f4ee7affe90e95920b22274f2","src/yelp.rs":"1fe3b7eb6b3f7462e9758b6eb62457dfa26f7549a8290cdff7637d2fb3ffea4f","uniffi.toml":"8205e4679ac26d53e70af0f85c013fd27cda1119f4322aebf5f2b9403d45a611"},"package":null}
+\ No newline at end of file
diff --git a/third_party/rust/suggest/Cargo.toml b/third_party/rust/suggest/Cargo.toml
@@ -38,18 +38,23 @@ path = "src/lib.rs"
 anyhow = "1.0"
 chrono = "0.4"
 extend = "1.1"
+icu_casemap = "2"
+icu_properties = "2"
 once_cell = "1.5"
 parking_lot = ">=0.11,<=0.12"
 rmp-serde = "1.3"
 serde_json = "1"
 thiserror = "2"
-unicase = "2.6"
-unicode-normalization = "0.1"
 
 [dependencies.error-support]
 path = "../support/error"
 features = ["tracing-logging"]
 
+[dependencies.icu_normalizer]
+version = "2"
+features = ["compiled_data"]
+default-features = false
+
 [dependencies.interrupt-support]
 path = "../support/interrupt"
 
diff --git a/third_party/rust/suggest/src/util.rs b/third_party/rust/suggest/src/util.rs
@@ -3,12 +3,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
+use icu_casemap::CaseMapperBorrowed;
+use icu_normalizer::DecomposingNormalizerBorrowed;
+use icu_properties::props::GeneralCategory;
+use icu_properties::props::GeneralCategoryGroup;
+use icu_properties::CodePointMapDataBorrowed;
 use std::borrow::Cow;
-use unicase::UniCase;
-use unicode_normalization::{char::is_combining_mark, UnicodeNormalization};
 
 use crate::Result;
 
+static NFKD: DecomposingNormalizerBorrowed = DecomposingNormalizerBorrowed::new_nfkd();
+static GENERAL_CATEGORY: CodePointMapDataBorrowed<'static, GeneralCategory> =
+    icu_properties::CodePointMapData::<GeneralCategory>::new();
+static CASE_MAPPER: CaseMapperBorrowed = CaseMapperBorrowed::new();
+
+fn is_combining_mark(c: char) -> bool {
+    GeneralCategoryGroup::Mark.contains(GENERAL_CATEGORY.get(c))
+}
+
 /// Given a list of keywords for a suggestion, returns a phrase that best
 /// completes the user's query. This function uses two heuristics to pick the
 /// best match:
@@ -253,8 +265,12 @@ pub fn split_keyword(keyword: &str) -> (&str, &str) {
 /// Compares two strings ignoring case, Unicode combining marks, and some
 /// punctuation. Intended to be used as a Sqlite collating sequence for
 /// comparing natural language strings like keywords and geoname names.
+///
+/// XXX: Should really be using `icu_collator` for collation!
 pub fn i18n_cmp(a: &str, b: &str) -> std::cmp::Ordering {
-    UniCase::new(i18n_transform(a)).cmp(&UniCase::new(i18n_transform(b)))
+    CASE_MAPPER
+        .fold_string(&i18n_transform(a))
+        .cmp(&CASE_MAPPER.fold_string(&i18n_transform(b)))
 }
 
 /// Performs the following transforms on the given string:
@@ -288,14 +304,17 @@ pub fn i18n_transform(s: &str) -> Cow<'_, str> {
         };
     }
 
-    let borrowable = !s
-        .nfkd()
+    let borrowable = !NFKD
+        .normalize_iter(s.chars())
         .any(|c| is_combining_mark(c) || matches!(c, pattern_all!()));
 
     if borrowable {
+        // XXX: This borrows the non-NFKD form, which sure looks like a bug,
+        // since NFKD can introduce changes that aren't caught by the check
+        // inside `any()` above.
         Cow::from(s)
     } else {
-        s.nfkd()
+        NFKD.normalize_iter(s.chars())
             .filter_map(|c| {
                 if is_combining_mark(c) {
                     // Remove Unicode combining marks:
diff --git a/third_party/rust/tinyvec/.cargo-checksum.json b/third_party/rust/tinyvec/.cargo-checksum.json
@@ -1 +0,0 @@
-{"files":{"CHANGELOG.md":"73712444deeadd5183a00d1bbf56b4fcd6396db0872020895f854631b6c6c309","Cargo.lock":"87e2a8a777227ec1bb50603f8bfbcc176c5a04dc6659d41b72e58cd56b843834","Cargo.toml":"d8ab8a7e7531a4ff6581880f1ab17beb32e2fb9c25772e68353da1c0cced01a5","LICENSE-APACHE.md":"3ddf9be5c28fe27dad143a5dc76eea25222ad1dd68934a047064e56ed2fa40c5","LICENSE-MIT.md":"4736b5d379253afa45744afc79ddb475912b213e939bdf7cb97d9a8b6f700e5f","LICENSE-ZLIB.md":"682b4c81b85e83ce6cc6e1ace38fdd97aeb4de0e972bd2b44aa0916c54af8c96","README.md":"0d8e58e1e52ebafe3f9a4a580d1b1f795c06b79aedad1197387205ef1590a173","benches/macros.rs":"b92679a63e1d39fd949c061fa97dfba933f3e1a6e6722e710cfe4fbfd6315ba9","benches/smallvec.rs":"3b86c05238638d9a894eaecd5a4e9875e2d1b3580cd880869f32a9c0ddab5576","debug_metadata/README.md":"ad8c829e14e40bf784808e7885009b1c016e94f0d578955df86efd245ce90d5e","debug_metadata/tinyvec.natvis":"bbddce08aacef999928071124cc0a8da7c66da4d45e1e79c69f5b617e704cce7","rustfmt.toml":"8a55552a7ab9bcd89add7014f0aeb9f80b491ddacc5f67f6988940f5d46c82b0","src/array.rs":"ab9e9abca8a76b1bec9e55f83f64c9db54980780a2dc88c13868f450caef5d0e","src/array/const_generic_impl.rs":"d0f8ae529b5c9f92da0aa67d5ae24a6e7fc3287ce6d3e576794455de44502a4c","src/array/generated_impl.rs":"8c94c274aae0909b7de75beff4215af8dfc8635cce0c09d75eb57e577c3cca68","src/array/generic_array_impl.rs":"cd8fd8f940e07badd47ab1d80b38e112f5ec09c559155e8857b6d95a85a06ead","src/arrayvec.rs":"bb3d6db2ea7bb362a379d169cc4423679f4a860a1c0744940b4ff653a9d8a372","src/arrayvec_drain.rs":"384738b646a766021886f7ccc32e7f42d5283c10b38b8c438ab049ca1139b0b8","src/lib.rs":"eef8d98214da0f56c1251411dd518e83abb72bb7dee6af5a71b5ab365afdaf68","src/slicevec.rs":"66b8fac4d3856378e3ad81ea9f97440a785f3659c923182435b80e8a7b0b9cbb","src/tinyvec.rs":"ad58bd2e1cdad8616fa96ebf84150c6fd3b3062f93c446347bde7e51ee4d18f0","tests/arrayvec.rs":"873c6a179ccc07ebd424028896483cd6661baac563447ff84cbf97cb100b60d5","tests/debugger_visualizer.rs":"27ffba7de85967678c9483c6e77a35c895c0cb8f594d188ccab34116d518af32","tests/tinyvec.rs":"4bdbe191ebe71c565d0b8cdf4177240016e1caf58b56f0ff5e5777a0028d09ef"},"package":"09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"}
-\ No newline at end of file
diff --git a/third_party/rust/tinyvec/CHANGELOG.md b/third_party/rust/tinyvec/CHANGELOG.md
@@ -1,104 +0,0 @@
-# Changelog
-
-## 1.9
-
-* Adds a `latest_stable_rust` cargo feature, which will automatically pull in
-  other cargo features related to the latest Stable version of rust.
-* Adds `ArrayVec::try_from_array_len`
-* Adds `TinyVec::into_vec` and `TinyVec::into_boxed_slice`
-* Adds support for `generic-array` crate
-* Adds support for the `borsh` crate
-
-## 1.8.1
-
-* [e00E](https://github.com/e00E) updated the rustc features so that they all
-  correctly depend on the lower version feature.
-  [pr 199](https://github.com/Lokathor/tinyvec/pull/199)
-
-## 1.8
-
-* [Fuuzetsu](https://github.com/Fuuzetsu) added the `ArrayVec::as_inner` method.
-  [pr 197](https://github.com/Lokathor/tinyvec/pull/197)
-
-## 1.7
-
-* [Fuuzetsu](https://github.com/Fuuzetsu) added the `rustc_1_61` cargo feature, which adds the `retain_mut` method.
-  [pr 198](https://github.com/Lokathor/tinyvec/pull/198) 
-
-## 1.6.1
-
-* [e00E](https://github.com/e00E) fixed the Arbitrary impl to work on Stable
-  without using a feature gate.
-  [pr 180](https://github.com/Lokathor/tinyvec/pull/180)
-
-## 1.6.0
-
-* [i509VCB](https://github.com/i509VCB) added the `try_` functions for fallable reallocation.
-  [pr 158](https://github.com/Lokathor/tinyvec/pull/158)
-* [ajtribick](https://github.com/ajtribick) added more error impls to `TryFromSliceError`.
-  [pr 160](https://github.com/Lokathor/tinyvec/pull/160)
-* The `std` feature now automatically enables the `alloc` feature as well.
-
-## 1.5.1
-
-* [madsmtm](https://github.com/madsmtm) fixed an error with the `alloc` feature on very old rustc versions.
-  [pr 154](https://github.com/Lokathor/tinyvec/pull/154)
-
-## 1.5.0
-
-* [eeeebbbbrrrr](https://github.com/eeeebbbbrrrr) added an impl for [std::io::Write](https://doc.rust-lang.org/std/io/trait.Write.html) to `TinyVec` when the element type is `u8`.
-  This is gated behind the new `std` feature.
-  [pr 152](https://github.com/Lokathor/tinyvec/pull/152)
-
-## 1.4.0
-
-* [saethlin](https://github.com/saethlin) stabilized the usage of const generics and array map with the `rustc_1_55` feature.
-  [pr 149](https://github.com/Lokathor/tinyvec/pull/149)
-
-## 1.3.1
-
-* Improved the performance of the `clone_from` method [pr 144](https://github.com/Lokathor/tinyvec/pull/144)
-
-## 1.3.0
-
-* [jeffa5](https://github.com/jeffa5) added arbitrary implementations for `TinyVec` and `ArrayVec` [pr 146](https://github.com/Lokathor/tinyvec/pull/146).
-* [elomatreb](https://github.com/elomatreb) implemented `DoubleEndedIterator` for `TinyVecIterator` [pr 145](https://github.com/Lokathor/tinyvec/pull/145).
-
-## 1.2.0
-
-* [Cryptjar](https://github.com/Cryptjar) removed the `A:Array` bound on the struct of `ArrayVec<A:Array>`,
-  and added the `from_array_empty` method, which is a `const fn` constructor
-  [pr 141](https://github.com/Lokathor/tinyvec/pull/141).
-
-## 1.1.1
-
-* [saethlin](https://github.com/saethlin) contributed many PRs (
-  [127](https://github.com/Lokathor/tinyvec/pull/127),
-  [128](https://github.com/Lokathor/tinyvec/pull/128),
-  [129](https://github.com/Lokathor/tinyvec/pull/129),
-  [131](https://github.com/Lokathor/tinyvec/pull/131),
-  [132](https://github.com/Lokathor/tinyvec/pull/132)
-  ) to help in several benchmarks.
-
-## 1.1.0
-
-* [slightlyoutofphase](https://github.com/slightlyoutofphase)
-  added "array splat" style syntax to the `array_vec!` and `tiny_vec!` macros.
-  You can now write `array_vec![true; 5]` and get a length 5 array vec full of `true`,
-  just like normal array initialization allows. Same goes for `tiny_vec!`.
-  ([pr 118](https://github.com/Lokathor/tinyvec/pull/118))
-* [not-a-seagull](https://github.com/not-a-seagull)
-  added `ArrayVec::into_inner` so that you can get the array out of an `ArrayVec`.
-  ([pr 124](https://github.com/Lokathor/tinyvec/pull/124))
-
-## 1.0.2
-
-* Added license files for the MIT and Apache-2.0 license options.
-
-## 1.0.1
-
-* Display additional features in the [docs.rs/tinyvec](https://docs.rs/tinyvec) documentation.
-
-## 1.0.0
-
-Initial Stable Release.
diff --git a/third_party/rust/tinyvec/Cargo.lock b/third_party/rust/tinyvec/Cargo.lock
@@ -1,647 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "aho-corasick"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247"
-
-[[package]]
-name = "arbitrary"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "borsh"
-version = "1.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5430e3be710b68d984d1391c854eb431a9d548640711faa54eecb1df93db91cc"
-dependencies = [
- "cfg_aliases",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.15.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
-
-[[package]]
-name = "cast"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "cfg_aliases"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
-
-[[package]]
-name = "clap"
-version = "2.34.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
-dependencies = [
- "bitflags",
- "textwrap",
- "unicode-width",
-]
-
-[[package]]
-name = "criterion"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f"
-dependencies = [
- "atty",
- "cast",
- "clap",
- "criterion-plot",
- "csv",
- "itertools",
- "lazy_static",
- "num-traits",
- "oorandom",
- "plotters",
- "rayon",
- "regex",
- "serde",
- "serde_cbor",
- "serde_derive",
- "serde_json",
- "tinytemplate",
- "walkdir",
-]
-
-[[package]]
-name = "criterion-plot"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876"
-dependencies = [
- "cast",
- "itertools",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
-
-[[package]]
-name = "csv"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
-dependencies = [
- "csv-core",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "debugger_test"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d95bb55f592fbb86947bee426d831de84bd65602a54f5cdcb10bfa70a62e52a0"
-dependencies = [
- "anyhow",
- "log",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "debugger_test_parser"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebe536452a777752b9316f0c840afbb94a2411684d4f15c081449ea801ef9e75"
-dependencies = [
- "anyhow",
- "log",
- "regex",
-]
-
-[[package]]
-name = "either"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
-
-[[package]]
-name = "generic-array"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8c8444bc9d71b935156cc0ccab7f622180808af7867b1daae6547d773591703"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "half"
-version = "1.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
-
-[[package]]
-name = "js-sys"
-version = "0.3.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.153"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
-
-[[package]]
-name = "log"
-version = "0.4.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
-
-[[package]]
-name = "memchr"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
-
-[[package]]
-name = "num-traits"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
-
-[[package]]
-name = "oorandom"
-version = "11.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
-
-[[package]]
-name = "plotters"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
-dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "plotters-backend"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
-
-[[package]]
-name = "plotters-svg"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
-dependencies = [
- "plotters-backend",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.79"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rayon"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
-dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "regex"
-version = "1.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
-
-[[package]]
-name = "ryu"
-version = "1.0.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
-
-[[package]]
-name = "same-file"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.197"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_cbor"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
-dependencies = [
- "half",
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.197"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.53",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.114"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_test"
-version = "1.0.176"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a2f49ace1498612d14f7e0b8245519584db8299541dfe31a06374a828d620ab"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "smallvec"
-version = "1.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.53"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7383cd0e49fff4b6b90ca5670bfd3e9d6a733b3f90c686605aa7eec8c4996032"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-dependencies = [
- "unicode-width",
-]
-
-[[package]]
-name = "tinytemplate"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
-dependencies = [
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "tinyvec"
-version = "1.9.0"
-dependencies = [
- "arbitrary",
- "borsh",
- "criterion",
- "debugger_test",
- "debugger_test_parser",
- "generic-array",
- "serde",
- "serde_test",
- "smallvec",
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
-[[package]]
-name = "typenum"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
-
-[[package]]
-name = "walkdir"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
-dependencies = [
- "same-file",
- "winapi-util",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
-dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn 2.0.53",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.53",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
-
-[[package]]
-name = "web-sys"
-version = "0.3.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-util"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/third_party/rust/tinyvec/Cargo.toml b/third_party/rust/tinyvec/Cargo.toml
@@ -1,158 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "tinyvec"
-version = "1.9.0"
-authors = ["Lokathor <zefria@gmail.com>"]
-build = false
-exclude = [
-    "/.github",
-    "/*.py",
-    "/*.sh",
-    "/src-backup",
-]
-autolib = false
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-description = "`tinyvec` provides 100% safe vec-like data structures."
-readme = "README.md"
-keywords = [
-    "vec",
-    "no_std",
-    "no-std",
-]
-categories = [
-    "data-structures",
-    "no-std",
-]
-license = "Zlib OR Apache-2.0 OR MIT"
-repository = "https://github.com/Lokathor/tinyvec"
-
-[package.metadata.docs.rs]
-features = [
-    "alloc",
-    "std",
-    "grab_spare_slice",
-    "latest_stable_rust",
-    "serde",
-    "borsh",
-]
-rustdoc-args = [
-    "--cfg",
-    "docs_rs",
-]
-
-[package.metadata.playground]
-features = [
-    "alloc",
-    "std",
-    "grab_spare_slice",
-    "latest_stable_rust",
-    "serde",
-    "borsh",
-]
-
-[features]
-alloc = ["tinyvec_macros"]
-debugger_visualizer = []
-default = []
-experimental_write_impl = []
-grab_spare_slice = []
-latest_stable_rust = ["rustc_1_61"]
-nightly_slice_partition_dedup = []
-real_blackbox = ["criterion/real_blackbox"]
-rustc_1_40 = []
-rustc_1_55 = ["rustc_1_40"]
-rustc_1_57 = ["rustc_1_55"]
-rustc_1_61 = ["rustc_1_57"]
-std = ["alloc"]
-
-[lib]
-name = "tinyvec"
-path = "src/lib.rs"
-
-[[test]]
-name = "arrayvec"
-path = "tests/arrayvec.rs"
-
-[[test]]
-name = "debugger_visualizer"
-path = "tests/debugger_visualizer.rs"
-test = false
-required-features = ["debugger_visualizer"]
-
-[[test]]
-name = "tinyvec"
-path = "tests/tinyvec.rs"
-required-features = [
-    "alloc",
-    "std",
-]
-
-[[bench]]
-name = "macros"
-path = "benches/macros.rs"
-harness = false
-required-features = ["alloc"]
-
-[[bench]]
-name = "smallvec"
-path = "benches/smallvec.rs"
-harness = false
-required-features = [
-    "alloc",
-    "real_blackbox",
-]
-
-[dependencies.arbitrary]
-version = "1"
-optional = true
-
-[dependencies.borsh]
-version = "1.2.0"
-optional = true
-default-features = false
-
-[dependencies.generic-array]
-version = "1.1.1"
-optional = true
-default-features = false
-
-[dependencies.serde]
-version = "1.0"
-optional = true
-default-features = false
-
-[dependencies.tinyvec_macros]
-version = "0.1"
-optional = true
-
-[dev-dependencies.criterion]
-version = "0.3.0"
-
-[dev-dependencies.debugger_test]
-version = "0.1"
-
-[dev-dependencies.debugger_test_parser]
-version = "0.1"
-
-[dev-dependencies.serde_test]
-version = "1.0"
-
-[dev-dependencies.smallvec]
-version = "1"
-
-[profile.bench]
-debug = 2
diff --git a/third_party/rust/tinyvec/LICENSE-APACHE.md b/third_party/rust/tinyvec/LICENSE-APACHE.md
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/third_party/rust/tinyvec/LICENSE-MIT.md b/third_party/rust/tinyvec/LICENSE-MIT.md
@@ -1,5 +0,0 @@
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/third_party/rust/tinyvec/LICENSE-ZLIB.md b/third_party/rust/tinyvec/LICENSE-ZLIB.md
@@ -1,11 +0,0 @@
-Copyright (c) 2019 Daniel "Lokathor" Gee.
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
diff --git a/third_party/rust/tinyvec/README.md b/third_party/rust/tinyvec/README.md
@@ -1,34 +0,0 @@
-[![License:Zlib](https://img.shields.io/badge/License-Zlib-brightgreen.svg)](https://opensource.org/licenses/Zlib)
-![Minimum Rust Version](https://img.shields.io/badge/Min%20Rust-1.47-green.svg)
-[![crates.io](https://img.shields.io/crates/v/tinyvec.svg)](https://crates.io/crates/tinyvec)
-[![docs.rs](https://docs.rs/tinyvec/badge.svg)](https://docs.rs/tinyvec/)
-
-![Unsafe-Zero-Percent](https://img.shields.io/badge/Unsafety-0%25-brightgreen.svg)
-
-# tinyvec
-
-A 100% safe crate of vec-like types.
-Not just safe at the public API boundary, fully safe for all internal code too: `#![forbid(unsafe_code)]`
-
-The provided types are as follows:
-* `ArrayVec` is an array-backed vec-like data structure. It panics on overflow.
-* `SliceVec` is similar, but using a `&mut [T]` as the data backing.
-* `TinyVec` (`alloc` feature) is an enum that's either an `Inline(ArrayVec)` or a `Heap(Vec)`.
-  If a `TinyVec` is `Inline` and would overflow its array it automatically transitions to `Heap` and continues whatever it was doing.
-
-To attain this "100% safe code" status there is one compromise: the element type of the vecs must implement `Default`.
-
-For more API details, please see [the docs.rs documentation](https://docs.rs/tinyvec/)
-
-## `tinyvec` Alternatives?
-
-Maybe you don't want to use `tinyvec`, there's other crates you might use instead!
-
-* [arrayvec](https://docs.rs/arrayvec) is a crate with array-backed structures.
-* [smallvec](https://docs.rs/smallvec) is a crate where the array-backed data can be moved to the heap on overflow.
-
-The main difference is that both of those crates use `unsafe` code.
-This mostly allows them to get rid of the `Default` limitation for elements that `tinyvec` imposes.
-The `smallvec` and `arrayvec` crates are generally correct, but there's been occasional bugs leading to UB.
-With `tinyvec`, any uncaught bugs *can't* lead to UB, because the crate is safe code all the way through.
-If you want that absolute level of assurance against UB, use `tinyvec`.
diff --git a/third_party/rust/tinyvec/benches/macros.rs b/third_party/rust/tinyvec/benches/macros.rs
@@ -1,52 +0,0 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-
-use tinyvec::tiny_vec;
-
-fn bench_tinyvec_macro(c: &mut Criterion) {
-  let mut g = c.benchmark_group("tinyvec_macro");
-
-  g.bench_function("0 of 32", |b| {
-    b.iter(|| tiny_vec!([u8; 32]));
-  });
-
-  g.bench_function("16 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-      )
-    });
-  });
-
-  g.bench_function("32 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
-      )
-    });
-  });
-
-  g.bench_function("33 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
-        33,
-      )
-    });
-  });
-
-  g.bench_function("64 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-        17, 18, 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, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
-      )
-    });
-  });
-}
-
-criterion_group!(benches, bench_tinyvec_macro);
-criterion_main!(benches);
diff --git a/third_party/rust/tinyvec/benches/smallvec.rs b/third_party/rust/tinyvec/benches/smallvec.rs
@@ -1,503 +0,0 @@
-//! Benchmarks that compare TinyVec to SmallVec
-//!
-//! All the following commentary is based on the latest nightly at the time:
-//! rustc 1.55.0 (c8dfcfe04 2021-09-06).
-//!
-//! Some of these benchmarks are just a few instructions, so we put our own for
-//! loop inside the criterion::Bencher::iter call. This seems to improve the
-//! stability of measurements, and it has the wonderful side effect of making
-//! the emitted assembly easier to follow. Some of these benchmarks are totally
-//! inlined so that there are no calls at all in the hot path, so finding
-//! this for loop is an easy way to find your way around the emitted assembly.
-//!
-//! The clear method is cheaper to call for arrays of elements without a Drop
-//! impl, so wherever possible we reuse a single object in the benchmark loop,
-//! with a clear + black_box on each iteration in an attempt to not make that
-//! visible to the optimizer.
-//!
-//! We always call black_box(&v), instead of v = black_box(v) because the latter
-//! does a move of the inline array, which is linear in the size of the array
-//! and thus varies based on the array type being benchmarked, and this move can
-//! be more expensive than the function we're trying to benchmark.
-//!
-//! We also black_box the input to each method call. This has a significant
-//! effect on the assembly emitted, for example if we do not black_box the range
-//! we iterate over in the ::push benchmarks, the loop is unrolled. It's not
-//! entirely clear if it's better to black_box the iterator that yields the
-//! items being pushed, or to black_box at a deeper level: v.push(black_box(i))
-//! for example. Anecdotally, it seems like the latter approach produces
-//! unreasonably bad assembly.
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use smallvec::SmallVec;
-use std::iter::FromIterator;
-use tinyvec::TinyVec;
-
-const ITERS: usize = 10_000;
-
-macro_rules! tinyvec_benches {
-  ($c:expr, $type:ty ; $len:expr) => {{
-    let mut g = $c.benchmark_group(concat!(
-      "TinyVec_",
-      stringify!($type),
-      "_",
-      stringify!($len)
-    ));
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::default"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: TinyVec<[$type; $len]> = TinyVec::default();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clone"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: TinyVec<[$type; $len]> =
-            black_box(TinyVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let v = outer.clone();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clear"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::push"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.push(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_iter"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: TinyVec<[$type; $len]> =
-              TinyVec::from_iter(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7];
-          for _ in 0..ITERS {
-            let v: TinyVec<[$type; $len]> = TinyVec::from(black_box(data));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend_from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]);
-          let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend_from_slice(data);
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::insert"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.insert(i as usize, i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::remove"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: TinyVec<[$type; $len]> =
-            black_box(TinyVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let mut v = outer.clone();
-            for i in black_box((0..=($len as usize - 1) as _).rev()) {
-              v.remove(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-  }};
-}
-
-fn tinyvec_benches(c: &mut Criterion) {
-  tinyvec_benches!(c, u8; 8);
-  tinyvec_benches!(c, u8; 16);
-  tinyvec_benches!(c, u8; 32);
-  tinyvec_benches!(c, u8; 64);
-  tinyvec_benches!(c, u8; 128);
-  tinyvec_benches!(c, u8; 256);
-  tinyvec_benches!(c, u64; 2);
-  tinyvec_benches!(c, u64; 4);
-  tinyvec_benches!(c, u64; 8);
-  tinyvec_benches!(c, u64; 16);
-  tinyvec_benches!(c, u64; 32);
-}
-
-macro_rules! smallvec_benches {
-  ($c:expr, $type:ty ; $len:expr) => {{
-    let mut g = $c.benchmark_group(concat!(
-      "SmallVec_",
-      stringify!($type),
-      "_",
-      stringify!($len)
-    ));
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::default"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: SmallVec<[$type; $len]> = SmallVec::default();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clone"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: SmallVec<[$type; $len]> =
-            black_box(SmallVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let v = outer.clone();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clear"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::push"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.push(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_iter"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: SmallVec<[$type; $len]> =
-              SmallVec::from_iter(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7];
-          for _ in 0..ITERS {
-            let v: SmallVec<[$type; $len]> = SmallVec::from(black_box(data));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend_from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]);
-          let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend_from_slice(data);
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::insert"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.insert(i as usize, i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::remove"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: SmallVec<[$type; $len]> =
-            black_box(SmallVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let mut v = outer.clone();
-            for i in black_box((0..=($len as usize - 1) as _).rev()) {
-              v.remove(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-  }};
-}
-
-fn smallvec_benches(c: &mut Criterion) {
-  smallvec_benches!(c, u8; 8);
-  smallvec_benches!(c, u8; 16);
-  smallvec_benches!(c, u8; 32);
-  smallvec_benches!(c, u8; 64);
-  smallvec_benches!(c, u8; 128);
-  smallvec_benches!(c, u8; 256);
-  smallvec_benches!(c, u64; 2);
-  smallvec_benches!(c, u64; 4);
-  smallvec_benches!(c, u64; 8);
-  smallvec_benches!(c, u64; 16);
-  smallvec_benches!(c, u64; 32);
-}
-
-criterion_group!(benches, tinyvec_benches, smallvec_benches);
-criterion_main!(benches);
diff --git a/third_party/rust/tinyvec/debug_metadata/README.md b/third_party/rust/tinyvec/debug_metadata/README.md
@@ -1,111 +0,0 @@
-## Debugger Visualizers
-
-Many languages and debuggers enable developers to control how a type is
-displayed in a debugger. These are called "debugger visualizations" or "debugger
-views".
-
-The Windows debuggers (WinDbg\CDB) support defining custom debugger visualizations using
-the `Natvis` framework. To use Natvis, developers write XML documents using the natvis
-schema that describe how debugger types should be displayed with the `.natvis` extension.
-(See: https://docs.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects?view=vs-2019)
-The Natvis files provide patterns which match type names a description of how to display
-those types.
-
-The Natvis schema can be found either online (See: https://code.visualstudio.com/docs/cpp/natvis#_schema)
-or locally at `<VS Installation Folder>\Xml\Schemas\1033\natvis.xsd`.
-
-The GNU debugger (GDB) supports defining custom debugger views using Pretty Printers.
-Pretty printers are written as python scripts that describe how a type should be displayed
-when loaded up in GDB/LLDB. (See: https://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html#Pretty-Printing)
-The pretty printers provide patterns, which match type names, and for matching
-types, describe how to display those types. (For writing a pretty printer, see: https://sourceware.org/gdb/onlinedocs/gdb/Writing-a-Pretty_002dPrinter.html#Writing-a-Pretty_002dPrinter).
-
-### Embedding Visualizers
-
-Through the use of the currently unstable `#[debugger_visualizer]` attribute, the `tinyvec`
-crate can embed debugger visualizers into the crate metadata.
-
-Currently the two types of visualizers supported are Natvis and Pretty printers.
-
-For Natvis files, when linking an executable with a crate that includes Natvis files,
-the MSVC linker will embed the contents of all Natvis files into the generated `PDB`.
-
-For pretty printers, the compiler will encode the contents of the pretty printer
-in the `.debug_gdb_scripts` section of the `ELF` generated.
-
-### Testing Visualizers
-
-The `tinyvec` crate supports testing debugger visualizers defined for this crate. The entry point for
-these tests are `tests/debugger_visualizer.rs`. These tests are defined using the `debugger_test` and
-`debugger_test_parser` crates. The `debugger_test` crate is a proc macro crate which defines a
-single proc macro attribute, `#[debugger_test]`. For more detailed information about this crate,
-see https://crates.io/crates/debugger_test. The CI pipeline for the `tinyvec` crate has been updated
-to run the debugger visualizer tests to ensure debugger visualizers do not become broken/stale.
-
-The `#[debugger_test]` proc macro attribute may only be used on test functions and will run the
-function under the debugger specified by the `debugger` meta item.
-
-This proc macro attribute has 3 required values:
-
-1. The first required meta item, `debugger`, takes a string value which specifies the debugger to launch.
-2. The second required meta item, `commands`, takes a string of new line (`\n`) separated list of debugger
-commands to run.
-3. The third required meta item, `expected_statements`, takes a string of new line (`\n`) separated list of
-statements that must exist in the debugger output. Pattern matching through regular expressions is also
-supported by using the `pattern:` prefix for each expected statement.
-
-#### Example:
-
-```rust
-#[debugger_test(
-    debugger = "cdb",
-    commands = "command1\ncommand2\ncommand3",
-    expected_statements = "statement1\nstatement2\nstatement3")]
-fn test() {
-
-}
-```
-
-Using a multiline string is also supported, with a single debugger command/expected statement per line:
-
-```rust
-#[debugger_test(
-    debugger = "cdb",
-    commands = "
-command1
-command2
-command3",
-    expected_statements = "
-statement1
-pattern:statement[0-9]+
-statement3")]
-fn test() {
-    
-}
-```
-
-In the example above, the second expected statement uses pattern matching through a regular expression
-by using the `pattern:` prefix.
-
-#### Testing Locally
-
-Currently, only Natvis visualizations have been defined for the `tinyvec` crate via `debug_metadata/tinyvec.natvis`,
-which means the `tests/debugger_visualizer.rs` tests need to be run on Windows using the `*-pc-windows-msvc` targets.
-To run these tests locally, first ensure the debugging tools for Windows are installed or install them following
-the steps listed here, [Debugging Tools for Windows](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/).
-Once the debugging tools have been installed, the tests can be run in the same manner as they are in the CI
-pipeline.
-
-#### Note
-
-When running the debugger visualizer tests, `tests/debugger_visualizer.rs`, they need to be run consecutively
-and not in parallel. This can be achieved by passing the flag `--test-threads=1` to rustc. This is due to
-how the debugger tests are run. Each test marked with the `#[debugger_test]` attribute launches a debugger
-and attaches it to the current test process. If tests are running in parallel, the test will try to attach
-a debugger to the current process which may already have a debugger attached causing the test to fail.
-
-For example:
-
-```
-cargo test --test debugger_visualizer --features debugger_visualizer -- --test-threads=1
-```
diff --git a/third_party/rust/tinyvec/debug_metadata/tinyvec.natvis b/third_party/rust/tinyvec/debug_metadata/tinyvec.natvis
@@ -1,24 +0,0 @@
-<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-  <Type Name="tinyvec::arrayvec::ArrayVec&lt;array$&lt;*,*&gt;&gt;">
-    <DisplayString>{{ len={len} }}</DisplayString>
-    <Expand>
-      <Item Name="[len]">len</Item>
-      <Item Name="[capacity]">$T2</Item>
-      <ArrayItems>
-        <Size>len</Size>
-        <ValuePointer>($T1*)data</ValuePointer>
-      </ArrayItems>
-    </Expand>
-  </Type>
-
-  <Type Name="tinyvec::slicevec::SliceVec&lt;*&gt;">
-    <DisplayString>{{ len={len} }}</DisplayString>
-    <Expand>
-      <Item Name="[len]">len</Item>
-      <ArrayItems>
-        <Size>len</Size>
-        <ValuePointer>data.data_ptr</ValuePointer>
-      </ArrayItems>
-    </Expand>
-  </Type>
-</AutoVisualizer>
-\ No newline at end of file
diff --git a/third_party/rust/tinyvec/rustfmt.toml b/third_party/rust/tinyvec/rustfmt.toml
@@ -1,14 +0,0 @@
-
-# Stable
-edition = "2018"
-fn_params_layout = "Compressed"
-max_width = 80
-tab_spaces = 2
-use_field_init_shorthand = true
-use_try_shorthand = true
-use_small_heuristics = "Max"
-
-# Unstable
-format_code_in_doc_comments = true
-wrap_comments = true
-imports_granularity = "Crate"
diff --git a/third_party/rust/tinyvec/src/array.rs b/third_party/rust/tinyvec/src/array.rs
@@ -1,54 +0,0 @@
-/// A trait for types that are an array.
-///
-/// An "array", for our purposes, has the following properties:
-/// * Owns some number of elements.
-/// * The element type can be generic, but must implement [`Default`].
-/// * The capacity is fixed at compile time, based on the implementing type.
-/// * You can get a shared or mutable slice to the elements.
-///
-/// You are generally **not** expected to need to implement this yourself. It is
-/// already implemented for all the major array lengths (`0..=32` and the powers
-/// of 2 up to 4,096), or for all array lengths with the feature `rustc_1_55`.
-///
-/// **Additional lengths can easily be added upon request.**
-///
-/// ## Safety Reminder
-///
-/// Just a reminder: this trait is 100% safe, which means that `unsafe` code
-/// **must not** rely on an instance of this trait being correct.
-pub trait Array {
-  /// The type of the items in the thing.
-  type Item: Default;
-
-  /// The number of slots in the thing.
-  const CAPACITY: usize;
-
-  /// Gives a shared slice over the whole thing.
-  ///
-  /// A correct implementation will return a slice with a length equal to the
-  /// `CAPACITY` value.
-  fn as_slice(&self) -> &[Self::Item];
-
-  /// Gives a unique slice over the whole thing.
-  ///
-  /// A correct implementation will return a slice with a length equal to the
-  /// `CAPACITY` value.
-  fn as_slice_mut(&mut self) -> &mut [Self::Item];
-
-  /// Create a default-initialized instance of ourself, similar to the
-  /// [`Default`] trait, but implemented for the same range of sizes as
-  /// [`Array`].
-  fn default() -> Self;
-}
-
-#[cfg(all(feature = "generic-array", not(feature = "rustc_1_55")))]
-core::compile_error!("generic-array requires `rustc_1_55` feature");
-
-#[cfg(feature = "rustc_1_55")]
-mod const_generic_impl;
-
-#[cfg(not(feature = "rustc_1_55"))]
-mod generated_impl;
-
-#[cfg(feature = "generic-array")]
-mod generic_array_impl;
diff --git a/third_party/rust/tinyvec/src/array/const_generic_impl.rs b/third_party/rust/tinyvec/src/array/const_generic_impl.rs
@@ -1,23 +0,0 @@
-use super::Array;
-
-impl<T: Default, const N: usize> Array for [T; N] {
-  type Item = T;
-  const CAPACITY: usize = N;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [(); N].map(|_| Default::default())
-  }
-}
diff --git a/third_party/rust/tinyvec/src/array/generated_impl.rs b/third_party/rust/tinyvec/src/array/generated_impl.rs
@@ -1,9616 +0,0 @@
-// Generated file, to regenerate run
-//     ./gen-array-impls.sh > src/array/generated_impl.rs
-// from the repo root
-
-use super::Array;
-
-impl<T: Default> Array for [T; 0] {
-  type Item = T;
-  const CAPACITY: usize = 0;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    []
-  }
-}
-
-impl<T: Default> Array for [T; 1] {
-  type Item = T;
-  const CAPACITY: usize = 1;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [T::default()]
-  }
-}
-
-impl<T: Default> Array for [T; 2] {
-  type Item = T;
-  const CAPACITY: usize = 2;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [T::default(), T::default()]
-  }
-}
-
-impl<T: Default> Array for [T; 3] {
-  type Item = T;
-  const CAPACITY: usize = 3;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [T::default(), T::default(), T::default()]
-  }
-}
-
-impl<T: Default> Array for [T; 4] {
-  type Item = T;
-  const CAPACITY: usize = 4;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [T::default(), T::default(), T::default(), T::default()]
-  }
-}
-
-impl<T: Default> Array for [T; 5] {
-  type Item = T;
-  const CAPACITY: usize = 5;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [T::default(), T::default(), T::default(), T::default(), T::default()]
-  }
-}
-
-impl<T: Default> Array for [T; 6] {
-  type Item = T;
-  const CAPACITY: usize = 6;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 7] {
-  type Item = T;
-  const CAPACITY: usize = 7;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 8] {
-  type Item = T;
-  const CAPACITY: usize = 8;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 9] {
-  type Item = T;
-  const CAPACITY: usize = 9;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 10] {
-  type Item = T;
-  const CAPACITY: usize = 10;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 11] {
-  type Item = T;
-  const CAPACITY: usize = 11;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 12] {
-  type Item = T;
-  const CAPACITY: usize = 12;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 13] {
-  type Item = T;
-  const CAPACITY: usize = 13;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 14] {
-  type Item = T;
-  const CAPACITY: usize = 14;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 15] {
-  type Item = T;
-  const CAPACITY: usize = 15;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 16] {
-  type Item = T;
-  const CAPACITY: usize = 16;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 17] {
-  type Item = T;
-  const CAPACITY: usize = 17;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 18] {
-  type Item = T;
-  const CAPACITY: usize = 18;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 19] {
-  type Item = T;
-  const CAPACITY: usize = 19;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 20] {
-  type Item = T;
-  const CAPACITY: usize = 20;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 21] {
-  type Item = T;
-  const CAPACITY: usize = 21;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 22] {
-  type Item = T;
-  const CAPACITY: usize = 22;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 23] {
-  type Item = T;
-  const CAPACITY: usize = 23;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 24] {
-  type Item = T;
-  const CAPACITY: usize = 24;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 25] {
-  type Item = T;
-  const CAPACITY: usize = 25;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 26] {
-  type Item = T;
-  const CAPACITY: usize = 26;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 27] {
-  type Item = T;
-  const CAPACITY: usize = 27;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 28] {
-  type Item = T;
-  const CAPACITY: usize = 28;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 29] {
-  type Item = T;
-  const CAPACITY: usize = 29;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 30] {
-  type Item = T;
-  const CAPACITY: usize = 30;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 31] {
-  type Item = T;
-  const CAPACITY: usize = 31;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 32] {
-  type Item = T;
-  const CAPACITY: usize = 32;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 33] {
-  type Item = T;
-  const CAPACITY: usize = 33;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 64] {
-  type Item = T;
-  const CAPACITY: usize = 64;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 128] {
-  type Item = T;
-  const CAPACITY: usize = 128;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 256] {
-  type Item = T;
-  const CAPACITY: usize = 256;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 512] {
-  type Item = T;
-  const CAPACITY: usize = 512;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 1024] {
-  type Item = T;
-  const CAPACITY: usize = 1024;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 2048] {
-  type Item = T;
-  const CAPACITY: usize = 2048;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
-
-impl<T: Default> Array for [T; 4096] {
-  type Item = T;
-  const CAPACITY: usize = 4096;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    [
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-      T::default(),
-    ]
-  }
-}
diff --git a/third_party/rust/tinyvec/src/array/generic_array_impl.rs b/third_party/rust/tinyvec/src/array/generic_array_impl.rs
@@ -1,26 +0,0 @@
-use core::default;
-
-use super::Array;
-use generic_array::{ArrayLength, GenericArray};
-
-impl<T: Default, N: ArrayLength> Array for GenericArray<T, N> {
-  type Item = T;
-  const CAPACITY: usize = N::USIZE;
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice(&self) -> &[T] {
-    &*self
-  }
-
-  #[inline(always)]
-  #[must_use]
-  fn as_slice_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-
-  #[inline(always)]
-  fn default() -> Self {
-    <Self as Default>::default()
-  }
-}
diff --git a/third_party/rust/tinyvec/src/arrayvec.rs b/third_party/rust/tinyvec/src/arrayvec.rs
@@ -1,2079 +0,0 @@
-use super::*;
-use core::convert::{TryFrom, TryInto};
-
-#[cfg(feature = "serde")]
-use core::marker::PhantomData;
-#[cfg(feature = "serde")]
-use serde::de::{
-  Deserialize, Deserializer, Error as DeserializeError, SeqAccess, Visitor,
-};
-#[cfg(feature = "serde")]
-use serde::ser::{Serialize, SerializeSeq, Serializer};
-
-/// Helper to make an `ArrayVec`.
-///
-/// You specify the backing array type, and optionally give all the elements you
-/// want to initially place into the array.
-///
-/// ```rust
-/// use tinyvec::*;
-///
-/// // The backing array type can be specified in the macro call
-/// let empty_av = array_vec!([u8; 16]);
-/// let some_ints = array_vec!([i32; 4] => 1, 2, 3);
-///
-/// // Or left to inference
-/// let empty_av: ArrayVec<[u8; 10]> = array_vec!();
-/// let some_ints: ArrayVec<[u8; 10]> = array_vec!(5, 6, 7, 8);
-/// ```
-#[macro_export]
-macro_rules! array_vec {
-  ($array_type:ty => $($elem:expr),* $(,)?) => {
-    {
-      let mut av: $crate::ArrayVec<$array_type> = Default::default();
-      $( av.push($elem); )*
-      av
-    }
-  };
-  ($array_type:ty) => {
-    $crate::ArrayVec::<$array_type>::default()
-  };
-  ($($elem:expr),*) => {
-    $crate::array_vec!(_ => $($elem),*)
-  };
-  ($elem:expr; $n:expr) => {
-    $crate::ArrayVec::from([$elem; $n])
-  };
-  () => {
-    $crate::array_vec!(_)
-  };
-}
-
-/// An array-backed, vector-like data structure.
-///
-/// * `ArrayVec` has a fixed capacity, equal to the minimum of the array size
-///   and `u16::MAX`. Note that not all capacities are necessarily supported by
-///   default. See comments in [`Array`].
-/// * `ArrayVec` has a variable length, as you add and remove elements. Attempts
-///   to fill the vec beyond its capacity will cause a panic.
-/// * All of the vec's array slots are always initialized in terms of Rust's
-///   memory model. When you remove a element from a location, the old value at
-///   that location is replaced with the type's default value.
-///
-/// The overall API of this type is intended to, as much as possible, emulate
-/// the API of the [`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)
-/// type.
-///
-/// ## Construction
-///
-/// You can use the `array_vec!` macro similarly to how you might use the `vec!`
-/// macro. Specify the array type, then optionally give all the initial values
-/// you want to have.
-/// ```rust
-/// # use tinyvec::*;
-/// let some_ints = array_vec!([i32; 4] => 1, 2, 3);
-/// assert_eq!(some_ints.len(), 3);
-/// ```
-///
-/// The [`default`](ArrayVec::new) for an `ArrayVec` is to have a default
-/// array with length 0. The [`new`](ArrayVec::new) method is the same as
-/// calling `default`
-/// ```rust
-/// # use tinyvec::*;
-/// let some_ints = ArrayVec::<[i32; 7]>::default();
-/// assert_eq!(some_ints.len(), 0);
-///
-/// let more_ints = ArrayVec::<[i32; 7]>::new();
-/// assert_eq!(some_ints, more_ints);
-/// ```
-///
-/// If you have an array and want the _whole thing_ so count as being "in" the
-/// new `ArrayVec` you can use one of the `from` implementations. If you want
-/// _part of_ the array then you can use
-/// [`from_array_len`](ArrayVec::from_array_len):
-/// ```rust
-/// # use tinyvec::*;
-/// let some_ints = ArrayVec::from([5, 6, 7, 8]);
-/// assert_eq!(some_ints.len(), 4);
-///
-/// let more_ints = ArrayVec::from_array_len([5, 6, 7, 8], 2);
-/// assert_eq!(more_ints.len(), 2);
-///
-/// let no_ints: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([1, 2, 3, 4, 5]);
-/// assert_eq!(no_ints.len(), 0);
-/// ```
-#[repr(C)]
-pub struct ArrayVec<A> {
-  len: u16,
-  pub(crate) data: A,
-}
-
-impl<A> Clone for ArrayVec<A>
-where
-  A: Array + Clone,
-  A::Item: Clone,
-{
-  #[inline]
-  fn clone(&self) -> Self {
-    Self { data: self.data.clone(), len: self.len }
-  }
-
-  #[inline]
-  fn clone_from(&mut self, o: &Self) {
-    let iter = self
-      .data
-      .as_slice_mut()
-      .iter_mut()
-      .zip(o.data.as_slice())
-      .take(self.len.max(o.len) as usize);
-    for (dst, src) in iter {
-      dst.clone_from(src)
-    }
-    if let Some(to_drop) =
-      self.data.as_slice_mut().get_mut((o.len as usize)..(self.len as usize))
-    {
-      to_drop.iter_mut().for_each(|x| drop(core::mem::take(x)));
-    }
-    self.len = o.len;
-  }
-}
-
-impl<A> Copy for ArrayVec<A>
-where
-  A: Array + Copy,
-  A::Item: Copy,
-{
-}
-
-impl<A: Array> Default for ArrayVec<A> {
-  #[inline]
-  fn default() -> Self {
-    Self { len: 0, data: A::default() }
-  }
-}
-
-impl<A: Array> Deref for ArrayVec<A> {
-  type Target = [A::Item];
-  #[inline(always)]
-  #[must_use]
-  fn deref(&self) -> &Self::Target {
-    &self.data.as_slice()[..self.len as usize]
-  }
-}
-
-impl<A: Array> DerefMut for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn deref_mut(&mut self) -> &mut Self::Target {
-    &mut self.data.as_slice_mut()[..self.len as usize]
-  }
-}
-
-impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for ArrayVec<A> {
-  type Output = <I as SliceIndex<[A::Item]>>::Output;
-  #[inline(always)]
-  #[must_use]
-  fn index(&self, index: I) -> &Self::Output {
-    &self.deref()[index]
-  }
-}
-
-impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn index_mut(&mut self, index: I) -> &mut Self::Output {
-    &mut self.deref_mut()[index]
-  }
-}
-
-#[cfg(feature = "serde")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "serde")))]
-impl<A: Array> Serialize for ArrayVec<A>
-where
-  A::Item: Serialize,
-{
-  #[must_use]
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: Serializer,
-  {
-    let mut seq = serializer.serialize_seq(Some(self.len()))?;
-    for element in self.iter() {
-      seq.serialize_element(element)?;
-    }
-    seq.end()
-  }
-}
-
-#[cfg(feature = "serde")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "serde")))]
-impl<'de, A: Array> Deserialize<'de> for ArrayVec<A>
-where
-  A::Item: Deserialize<'de>,
-{
-  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-  where
-    D: Deserializer<'de>,
-  {
-    deserializer.deserialize_seq(ArrayVecVisitor(PhantomData))
-  }
-}
-
-#[cfg(feature = "borsh")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "borsh")))]
-impl<A: Array> borsh::BorshSerialize for ArrayVec<A>
-where
-  <A as Array>::Item: borsh::BorshSerialize,
-{
-  fn serialize<W: borsh::io::Write>(
-    &self, writer: &mut W,
-  ) -> borsh::io::Result<()> {
-    <usize as borsh::BorshSerialize>::serialize(&self.len(), writer)?;
-    for elem in self.iter() {
-      <<A as Array>::Item as borsh::BorshSerialize>::serialize(elem, writer)?;
-    }
-    Ok(())
-  }
-}
-
-#[cfg(feature = "borsh")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "borsh")))]
-impl<A: Array> borsh::BorshDeserialize for ArrayVec<A>
-where
-  <A as Array>::Item: borsh::BorshDeserialize,
-{
-  fn deserialize_reader<R: borsh::io::Read>(
-    reader: &mut R,
-  ) -> borsh::io::Result<Self> {
-    let len = <usize as borsh::BorshDeserialize>::deserialize_reader(reader)?;
-    let mut new_arrayvec = Self::default();
-
-    for idx in 0..len {
-      let value =
-        <<A as Array>::Item as borsh::BorshDeserialize>::deserialize_reader(
-          reader,
-        )?;
-      if idx >= new_arrayvec.capacity() {
-        return Err(borsh::io::Error::new(
-          borsh::io::ErrorKind::InvalidData,
-          "invalid ArrayVec length",
-        ));
-      }
-      new_arrayvec.push(value)
-    }
-
-    Ok(new_arrayvec)
-  }
-}
-
-#[cfg(feature = "arbitrary")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "arbitrary")))]
-impl<'a, A> arbitrary::Arbitrary<'a> for ArrayVec<A>
-where
-  A: Array,
-  A::Item: arbitrary::Arbitrary<'a>,
-{
-  fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-    let max_len = A::CAPACITY.min(u16::MAX as usize) as u16;
-    let len = u.int_in_range::<u16>(0..=max_len)?;
-    let mut self_: Self = Default::default();
-    for _ in 0..len {
-      self_.push(u.arbitrary()?);
-    }
-    Ok(self_)
-  }
-
-  fn size_hint(depth: usize) -> (usize, Option<usize>) {
-    arbitrary::size_hint::recursion_guard(depth, |depth| {
-      let max_len = A::CAPACITY.min(u16::MAX as usize);
-      let inner = A::Item::size_hint(depth).1;
-      (0, inner.map(|inner| 2 + max_len * inner))
-    })
-  }
-}
-
-impl<A: Array> ArrayVec<A> {
-  /// Move all values from `other` into this vec.
-  ///
-  /// ## Panics
-  /// * If the vec overflows its capacity
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 10] => 1, 2, 3);
-  /// let mut av2 = array_vec!([i32; 10] => 4, 5, 6);
-  /// av.append(&mut av2);
-  /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
-  /// assert_eq!(av2, &[][..]);
-  /// ```
-  #[inline]
-  pub fn append(&mut self, other: &mut Self) {
-    assert!(
-      self.try_append(other).is_none(),
-      "ArrayVec::append> total length {} exceeds capacity {}!",
-      self.len() + other.len(),
-      A::CAPACITY
-    );
-  }
-
-  /// Move all values from `other` into this vec.
-  /// If appending would overflow the capacity, Some(other) is returned.
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 7] => 1, 2, 3);
-  /// let mut av2 = array_vec!([i32; 7] => 4, 5, 6);
-  /// av.append(&mut av2);
-  /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
-  /// assert_eq!(av2, &[][..]);
-  ///
-  /// let mut av3 = array_vec!([i32; 7] => 7, 8, 9);
-  /// assert!(av.try_append(&mut av3).is_some());
-  /// assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
-  /// assert_eq!(av3, &[7, 8, 9][..]);
-  /// ```
-  #[inline]
-  pub fn try_append<'other>(
-    &mut self, other: &'other mut Self,
-  ) -> Option<&'other mut Self> {
-    let new_len = self.len() + other.len();
-    if new_len > A::CAPACITY {
-      return Some(other);
-    }
-
-    let iter = other.iter_mut().map(core::mem::take);
-    for item in iter {
-      self.push(item);
-    }
-
-    other.set_len(0);
-
-    return None;
-  }
-
-  /// A `*mut` pointer to the backing array.
-  ///
-  /// ## Safety
-  ///
-  /// This pointer has provenance over the _entire_ backing array.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_mut_ptr(&mut self) -> *mut A::Item {
-    self.data.as_slice_mut().as_mut_ptr()
-  }
-
-  /// Performs a `deref_mut`, into unique slice form.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_mut_slice(&mut self) -> &mut [A::Item] {
-    self.deref_mut()
-  }
-
-  /// A `*const` pointer to the backing array.
-  ///
-  /// ## Safety
-  ///
-  /// This pointer has provenance over the _entire_ backing array.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_ptr(&self) -> *const A::Item {
-    self.data.as_slice().as_ptr()
-  }
-
-  /// Performs a `deref`, into shared slice form.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_slice(&self) -> &[A::Item] {
-    self.deref()
-  }
-
-  /// The capacity of the `ArrayVec`.
-  ///
-  /// This is fixed based on the array type, but can't yet be made a `const fn`
-  /// on Stable Rust.
-  #[inline(always)]
-  #[must_use]
-  pub fn capacity(&self) -> usize {
-    // Note: This shouldn't use A::CAPACITY, because unsafe code can't rely on
-    // any Array invariants. This ensures that at the very least, the returned
-    // value is a valid length for a subslice of the backing array.
-    self.data.as_slice().len().min(u16::MAX as usize)
-  }
-
-  /// Truncates the `ArrayVec` down to length 0.
-  #[inline(always)]
-  pub fn clear(&mut self) {
-    self.truncate(0)
-  }
-
-  /// Creates a draining iterator that removes the specified range in the vector
-  /// and yields the removed items.
-  ///
-  /// ## Panics
-  /// * If the start is greater than the end
-  /// * If the end is past the edge of the vec.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4] => 1, 2, 3);
-  /// let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect();
-  /// assert_eq!(av.as_slice(), &[1][..]);
-  /// assert_eq!(av2.as_slice(), &[2, 3][..]);
-  ///
-  /// av.drain(..);
-  /// assert_eq!(av.as_slice(), &[]);
-  /// ```
-  #[inline]
-  pub fn drain<R>(&mut self, range: R) -> ArrayVecDrain<'_, A::Item>
-  where
-    R: RangeBounds<usize>,
-  {
-    ArrayVecDrain::new(self, range)
-  }
-
-  /// Returns the inner array of the `ArrayVec`.
-  ///
-  /// This returns the full array, even if the `ArrayVec` length is currently
-  /// less than that.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::{array_vec, ArrayVec};
-  /// let mut favorite_numbers = array_vec!([i32; 5] => 87, 48, 33, 9, 26);
-  /// assert_eq!(favorite_numbers.clone().into_inner(), [87, 48, 33, 9, 26]);
-  ///
-  /// favorite_numbers.pop();
-  /// assert_eq!(favorite_numbers.into_inner(), [87, 48, 33, 9, 0]);
-  /// ```
-  ///
-  /// A use for this function is to build an array from an iterator by first
-  /// collecting it into an `ArrayVec`.
-  ///
-  /// ```rust
-  /// # use tinyvec::ArrayVec;
-  /// let arr_vec: ArrayVec<[i32; 10]> = (1..=3).cycle().take(10).collect();
-  /// let inner = arr_vec.into_inner();
-  /// assert_eq!(inner, [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]);
-  /// ```
-  #[inline]
-  pub fn into_inner(self) -> A {
-    self.data
-  }
-
-  /// Clone each element of the slice into this `ArrayVec`.
-  ///
-  /// ## Panics
-  /// * If the `ArrayVec` would overflow, this will panic.
-  #[inline]
-  pub fn extend_from_slice(&mut self, sli: &[A::Item])
-  where
-    A::Item: Clone,
-  {
-    if sli.is_empty() {
-      return;
-    }
-
-    let new_len = self.len as usize + sli.len();
-    assert!(
-      new_len <= A::CAPACITY,
-      "ArrayVec::extend_from_slice> total length {} exceeds capacity {}!",
-      new_len,
-      A::CAPACITY
-    );
-
-    let target = &mut self.data.as_slice_mut()[self.len as usize..new_len];
-    target.clone_from_slice(sli);
-    self.set_len(new_len);
-  }
-
-  /// Fill the vector until its capacity has been reached.
-  ///
-  /// Successively fills unused space in the spare slice of the vector with
-  /// elements from the iterator. It then returns the remaining iterator
-  /// without exhausting it. This also allows appending the head of an
-  /// infinite iterator.
-  ///
-  /// This is an alternative to `Extend::extend` method for cases where the
-  /// length of the iterator can not be checked. Since this vector can not
-  /// reallocate to increase its capacity, it is unclear what to do with
-  /// remaining elements in the iterator and the iterator itself. The
-  /// interface also provides no way to communicate this to the caller.
-  ///
-  /// ## Panics
-  /// * If the `next` method of the provided iterator panics.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4]);
-  /// let mut to_inf = av.fill(0..);
-  /// assert_eq!(&av[..], [0, 1, 2, 3]);
-  /// assert_eq!(to_inf.next(), Some(4));
-  /// ```
-  #[inline]
-  pub fn fill<I: IntoIterator<Item = A::Item>>(
-    &mut self, iter: I,
-  ) -> I::IntoIter {
-    // If this is written as a call to push for each element in iter, the
-    // compiler emits code that updates the length for every element. The
-    // additional complexity from that length update is worth nearly 2x in
-    // the runtime of this function.
-    let mut iter = iter.into_iter();
-    let mut pushed = 0;
-    let to_take = self.capacity() - self.len();
-    let target = &mut self.data.as_slice_mut()[self.len as usize..];
-    for element in iter.by_ref().take(to_take) {
-      target[pushed] = element;
-      pushed += 1;
-    }
-    self.len += pushed as u16;
-    iter
-  }
-
-  /// Wraps up an array and uses the given length as the initial length.
-  ///
-  /// If you want to simply use the full array, use `from` instead.
-  ///
-  /// ## Panics
-  ///
-  /// * The length specified must be less than or equal to the capacity of the
-  ///   array.
-  #[inline]
-  #[must_use]
-  #[allow(clippy::match_wild_err_arm)]
-  pub fn from_array_len(data: A, len: usize) -> Self {
-    match Self::try_from_array_len(data, len) {
-      Ok(out) => out,
-      Err(_) => panic!(
-        "ArrayVec::from_array_len> length {} exceeds capacity {}!",
-        len,
-        A::CAPACITY
-      ),
-    }
-  }
-
-  /// Inserts an item at the position given, moving all following elements +1
-  /// index.
-  ///
-  /// ## Panics
-  /// * If `index` > `len`
-  /// * If the capacity is exhausted
-  ///
-  /// ## Example
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut av = array_vec!([i32; 10] => 1, 2, 3);
-  /// av.insert(1, 4);
-  /// assert_eq!(av.as_slice(), &[1, 4, 2, 3]);
-  /// av.insert(4, 5);
-  /// assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);
-  /// ```
-  #[inline]
-  pub fn insert(&mut self, index: usize, item: A::Item) {
-    let x = self.try_insert(index, item);
-    assert!(x.is_none(), "ArrayVec::insert> capacity overflow!");
-  }
-
-  /// Tries to insert an item at the position given, moving all following
-  /// elements +1 index.
-  /// Returns back the element if the capacity is exhausted,
-  /// otherwise returns None.
-  ///
-  /// ## Panics
-  /// * If `index` > `len`
-  ///
-  /// ## Example
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut av = array_vec!([&'static str; 4] => "one", "two", "three");
-  /// av.insert(1, "four");
-  /// assert_eq!(av.as_slice(), &["one", "four", "two", "three"]);
-  /// assert_eq!(av.try_insert(4, "five"), Some("five"));
-  /// ```
-  #[inline]
-  pub fn try_insert(
-    &mut self, index: usize, mut item: A::Item,
-  ) -> Option<A::Item> {
-    assert!(
-      index <= self.len as usize,
-      "ArrayVec::try_insert> index {} is out of bounds {}",
-      index,
-      self.len
-    );
-
-    // A previous implementation used self.try_push and slice::rotate_right
-    // rotate_right and rotate_left generate a huge amount of code and fail to
-    // inline; calling them here incurs the cost of all the cases they
-    // handle even though we're rotating a usually-small array by a constant
-    // 1 offset. This swap-based implementation benchmarks much better for
-    // small array lengths in particular.
-
-    if (self.len as usize) < A::CAPACITY {
-      self.len += 1;
-    } else {
-      return Some(item);
-    }
-
-    let target = &mut self.as_mut_slice()[index..];
-    #[allow(clippy::needless_range_loop)]
-    for i in 0..target.len() {
-      core::mem::swap(&mut item, &mut target[i]);
-    }
-    return None;
-  }
-
-  /// Checks if the length is 0.
-  #[inline(always)]
-  #[must_use]
-  pub fn is_empty(&self) -> bool {
-    self.len == 0
-  }
-
-  /// The length of the `ArrayVec` (in elements).
-  #[inline(always)]
-  #[must_use]
-  pub fn len(&self) -> usize {
-    self.len as usize
-  }
-
-  /// Makes a new, empty `ArrayVec`.
-  #[inline(always)]
-  #[must_use]
-  pub fn new() -> Self {
-    Self::default()
-  }
-
-  /// Remove and return the last element of the vec, if there is one.
-  ///
-  /// ## Failure
-  /// * If the vec is empty you get `None`.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 10] => 1, 2);
-  /// assert_eq!(av.pop(), Some(2));
-  /// assert_eq!(av.pop(), Some(1));
-  /// assert_eq!(av.pop(), None);
-  /// ```
-  #[inline]
-  pub fn pop(&mut self) -> Option<A::Item> {
-    if self.len > 0 {
-      self.len -= 1;
-      let out =
-        core::mem::take(&mut self.data.as_slice_mut()[self.len as usize]);
-      Some(out)
-    } else {
-      None
-    }
-  }
-
-  /// Place an element onto the end of the vec.
-  ///
-  /// ## Panics
-  /// * If the length of the vec would overflow the capacity.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 2]);
-  /// assert_eq!(&av[..], []);
-  /// av.push(1);
-  /// assert_eq!(&av[..], [1]);
-  /// av.push(2);
-  /// assert_eq!(&av[..], [1, 2]);
-  /// // av.push(3); this would overflow the ArrayVec and panic!
-  /// ```
-  #[inline(always)]
-  pub fn push(&mut self, val: A::Item) {
-    let x = self.try_push(val);
-    assert!(x.is_none(), "ArrayVec::push> capacity overflow!");
-  }
-
-  /// Tries to place an element onto the end of the vec.\
-  /// Returns back the element if the capacity is exhausted,
-  /// otherwise returns None.
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 2]);
-  /// assert_eq!(av.as_slice(), []);
-  /// assert_eq!(av.try_push(1), None);
-  /// assert_eq!(&av[..], [1]);
-  /// assert_eq!(av.try_push(2), None);
-  /// assert_eq!(&av[..], [1, 2]);
-  /// assert_eq!(av.try_push(3), Some(3));
-  /// ```
-  #[inline(always)]
-  pub fn try_push(&mut self, val: A::Item) -> Option<A::Item> {
-    debug_assert!(self.len as usize <= A::CAPACITY);
-
-    let itemref = match self.data.as_slice_mut().get_mut(self.len as usize) {
-      None => return Some(val),
-      Some(x) => x,
-    };
-
-    *itemref = val;
-    self.len += 1;
-    return None;
-  }
-
-  /// Removes the item at `index`, shifting all others down by one index.
-  ///
-  /// Returns the removed element.
-  ///
-  /// ## Panics
-  ///
-  /// * If the index is out of bounds.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4] => 1, 2, 3);
-  /// assert_eq!(av.remove(1), 2);
-  /// assert_eq!(&av[..], [1, 3]);
-  /// ```
-  #[inline]
-  pub fn remove(&mut self, index: usize) -> A::Item {
-    let targets: &mut [A::Item] = &mut self.deref_mut()[index..];
-    let item = core::mem::take(&mut targets[0]);
-
-    // A previous implementation used rotate_left
-    // rotate_right and rotate_left generate a huge amount of code and fail to
-    // inline; calling them here incurs the cost of all the cases they
-    // handle even though we're rotating a usually-small array by a constant
-    // 1 offset. This swap-based implementation benchmarks much better for
-    // small array lengths in particular.
-
-    for i in 0..targets.len() - 1 {
-      targets.swap(i, i + 1);
-    }
-    self.len -= 1;
-    item
-  }
-
-  /// As [`resize_with`](ArrayVec::resize_with)
-  /// and it clones the value as the closure.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  ///
-  /// let mut av = array_vec!([&str; 10] => "hello");
-  /// av.resize(3, "world");
-  /// assert_eq!(&av[..], ["hello", "world", "world"]);
-  ///
-  /// let mut av = array_vec!([i32; 10] => 1, 2, 3, 4);
-  /// av.resize(2, 0);
-  /// assert_eq!(&av[..], [1, 2]);
-  /// ```
-  #[inline]
-  pub fn resize(&mut self, new_len: usize, new_val: A::Item)
-  where
-    A::Item: Clone,
-  {
-    self.resize_with(new_len, || new_val.clone())
-  }
-
-  /// Resize the vec to the new length.
-  ///
-  /// If it needs to be longer, it's filled with repeated calls to the provided
-  /// function. If it needs to be shorter, it's truncated.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  ///
-  /// let mut av = array_vec!([i32; 10] => 1, 2, 3);
-  /// av.resize_with(5, Default::default);
-  /// assert_eq!(&av[..], [1, 2, 3, 0, 0]);
-  ///
-  /// let mut av = array_vec!([i32; 10]);
-  /// let mut p = 1;
-  /// av.resize_with(4, || {
-  ///   p *= 2;
-  ///   p
-  /// });
-  /// assert_eq!(&av[..], [2, 4, 8, 16]);
-  /// ```
-  #[inline]
-  pub fn resize_with<F: FnMut() -> A::Item>(
-    &mut self, new_len: usize, mut f: F,
-  ) {
-    match new_len.checked_sub(self.len as usize) {
-      None => self.truncate(new_len),
-      Some(new_elements) => {
-        for _ in 0..new_elements {
-          self.push(f());
-        }
-      }
-    }
-  }
-
-  /// Walk the vec and keep only the elements that pass the predicate given.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  ///
-  /// let mut av = array_vec!([i32; 10] => 1, 1, 2, 3, 3, 4);
-  /// av.retain(|&x| x % 2 == 0);
-  /// assert_eq!(&av[..], [2, 4]);
-  /// ```
-  #[inline]
-  pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, mut acceptable: F) {
-    // Drop guard to contain exactly the remaining elements when the test
-    // panics.
-    struct JoinOnDrop<'vec, Item> {
-      items: &'vec mut [Item],
-      done_end: usize,
-      // Start of tail relative to `done_end`.
-      tail_start: usize,
-    }
-
-    impl<Item> Drop for JoinOnDrop<'_, Item> {
-      fn drop(&mut self) {
-        self.items[self.done_end..].rotate_left(self.tail_start);
-      }
-    }
-
-    let mut rest = JoinOnDrop {
-      items: &mut self.data.as_slice_mut()[..self.len as usize],
-      done_end: 0,
-      tail_start: 0,
-    };
-
-    let len = self.len as usize;
-    for idx in 0..len {
-      // Loop start invariant: idx = rest.done_end + rest.tail_start
-      if !acceptable(&rest.items[idx]) {
-        let _ = core::mem::take(&mut rest.items[idx]);
-        self.len -= 1;
-        rest.tail_start += 1;
-      } else {
-        rest.items.swap(rest.done_end, idx);
-        rest.done_end += 1;
-      }
-    }
-  }
-
-  /// Retains only the elements specified by the predicate, passing a mutable
-  /// reference to it.
-  ///
-  /// In other words, remove all elements e such that f(&mut e) returns false.
-  /// This method operates in place, visiting each element exactly once in the
-  /// original order, and preserves the order of the retained elements.
-  ///
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  ///
-  /// let mut av = array_vec!([i32; 10] => 1, 1, 2, 3, 3, 4);
-  /// av.retain_mut(|x| if *x % 2 == 0 { *x *= 2; true } else { false });
-  /// assert_eq!(&av[..], [4, 8]);
-  /// ```
-  #[inline]
-  pub fn retain_mut<F>(&mut self, mut acceptable: F)
-  where
-    F: FnMut(&mut A::Item) -> bool,
-  {
-    // Drop guard to contain exactly the remaining elements when the test
-    // panics.
-    struct JoinOnDrop<'vec, Item> {
-      items: &'vec mut [Item],
-      done_end: usize,
-      // Start of tail relative to `done_end`.
-      tail_start: usize,
-    }
-
-    impl<Item> Drop for JoinOnDrop<'_, Item> {
-      fn drop(&mut self) {
-        self.items[self.done_end..].rotate_left(self.tail_start);
-      }
-    }
-
-    let mut rest = JoinOnDrop {
-      items: &mut self.data.as_slice_mut()[..self.len as usize],
-      done_end: 0,
-      tail_start: 0,
-    };
-
-    let len = self.len as usize;
-    for idx in 0..len {
-      // Loop start invariant: idx = rest.done_end + rest.tail_start
-      if !acceptable(&mut rest.items[idx]) {
-        let _ = core::mem::take(&mut rest.items[idx]);
-        self.len -= 1;
-        rest.tail_start += 1;
-      } else {
-        rest.items.swap(rest.done_end, idx);
-        rest.done_end += 1;
-      }
-    }
-  }
-
-  /// Forces the length of the vector to `new_len`.
-  ///
-  /// ## Panics
-  /// * If `new_len` is greater than the vec's capacity.
-  ///
-  /// ## Safety
-  /// * This is a fully safe operation! The inactive memory already counts as
-  ///   "initialized" by Rust's rules.
-  /// * Other than "the memory is initialized" there are no other guarantees
-  ///   regarding what you find in the inactive portion of the vec.
-  #[inline(always)]
-  pub fn set_len(&mut self, new_len: usize) {
-    if new_len > A::CAPACITY {
-      // Note(Lokathor): Technically we don't have to panic here, and we could
-      // just let some other call later on trigger a panic on accident when the
-      // length is wrong. However, it's a lot easier to catch bugs when things
-      // are more "fail-fast".
-      panic!(
-        "ArrayVec::set_len> new length {} exceeds capacity {}",
-        new_len,
-        A::CAPACITY
-      )
-    }
-
-    let new_len: u16 = new_len
-      .try_into()
-      .expect("ArrayVec::set_len> new length is not in range 0..=u16::MAX");
-    self.len = new_len;
-  }
-
-  /// Splits the collection at the point given.
-  ///
-  /// * `[0, at)` stays in this vec
-  /// * `[at, len)` ends up in the new vec.
-  ///
-  /// ## Panics
-  /// * if at > len
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4] => 1, 2, 3);
-  /// let av2 = av.split_off(1);
-  /// assert_eq!(&av[..], [1]);
-  /// assert_eq!(&av2[..], [2, 3]);
-  /// ```
-  #[inline]
-  pub fn split_off(&mut self, at: usize) -> Self {
-    // FIXME: should this just use drain into the output?
-    if at > self.len() {
-      panic!(
-        "ArrayVec::split_off> at value {} exceeds length of {}",
-        at, self.len
-      );
-    }
-    let mut new = Self::default();
-    let moves = &mut self.as_mut_slice()[at..];
-    let split_len = moves.len();
-    let targets = &mut new.data.as_slice_mut()[..split_len];
-    moves.swap_with_slice(targets);
-
-    /* moves.len() <= u16::MAX, so these are surely in u16 range */
-    new.len = split_len as u16;
-    self.len = at as u16;
-    new
-  }
-
-  /// Creates a splicing iterator that removes the specified range in the
-  /// vector, yields the removed items, and replaces them with elements from
-  /// the provided iterator.
-  ///
-  /// `splice` fuses the provided iterator, so elements after the first `None`
-  /// are ignored.
-  ///
-  /// ## Panics
-  /// * If the start is greater than the end.
-  /// * If the end is past the edge of the vec.
-  /// * If the provided iterator panics.
-  /// * If the new length would overflow the capacity of the array. Because
-  ///   `ArrayVecSplice` adds elements to this vec in its destructor when
-  ///   necessary, this panic would occur when it is dropped.
-  ///
-  /// ## Example
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4] => 1, 2, 3);
-  /// let av2: ArrayVec<[i32; 4]> = av.splice(1.., 4..=6).collect();
-  /// assert_eq!(av.as_slice(), &[1, 4, 5, 6][..]);
-  /// assert_eq!(av2.as_slice(), &[2, 3][..]);
-  ///
-  /// av.splice(.., None);
-  /// assert_eq!(av.as_slice(), &[]);
-  /// ```
-  #[inline]
-  pub fn splice<R, I>(
-    &mut self, range: R, replacement: I,
-  ) -> ArrayVecSplice<'_, A, core::iter::Fuse<I::IntoIter>>
-  where
-    R: RangeBounds<usize>,
-    I: IntoIterator<Item = A::Item>,
-  {
-    use core::ops::Bound;
-    let start = match range.start_bound() {
-      Bound::Included(x) => *x,
-      Bound::Excluded(x) => x.saturating_add(1),
-      Bound::Unbounded => 0,
-    };
-    let end = match range.end_bound() {
-      Bound::Included(x) => x.saturating_add(1),
-      Bound::Excluded(x) => *x,
-      Bound::Unbounded => self.len(),
-    };
-    assert!(
-      start <= end,
-      "ArrayVec::splice> Illegal range, {} to {}",
-      start,
-      end
-    );
-    assert!(
-      end <= self.len(),
-      "ArrayVec::splice> Range ends at {} but length is only {}!",
-      end,
-      self.len()
-    );
-
-    ArrayVecSplice {
-      removal_start: start,
-      removal_end: end,
-      parent: self,
-      replacement: replacement.into_iter().fuse(),
-    }
-  }
-
-  /// Remove an element, swapping the end of the vec into its place.
-  ///
-  /// ## Panics
-  /// * If the index is out of bounds.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([&str; 4] => "foo", "bar", "quack", "zap");
-  ///
-  /// assert_eq!(av.swap_remove(1), "bar");
-  /// assert_eq!(&av[..], ["foo", "zap", "quack"]);
-  ///
-  /// assert_eq!(av.swap_remove(0), "foo");
-  /// assert_eq!(&av[..], ["quack", "zap"]);
-  /// ```
-  #[inline]
-  pub fn swap_remove(&mut self, index: usize) -> A::Item {
-    assert!(
-      index < self.len(),
-      "ArrayVec::swap_remove> index {} is out of bounds {}",
-      index,
-      self.len
-    );
-    if index == self.len() - 1 {
-      self.pop().unwrap()
-    } else {
-      let i = self.pop().unwrap();
-      replace(&mut self[index], i)
-    }
-  }
-
-  /// Reduces the vec's length to the given value.
-  ///
-  /// If the vec is already shorter than the input, nothing happens.
-  #[inline]
-  pub fn truncate(&mut self, new_len: usize) {
-    if new_len >= self.len as usize {
-      return;
-    }
-
-    if needs_drop::<A::Item>() {
-      let len = self.len as usize;
-      self.data.as_slice_mut()[new_len..len]
-        .iter_mut()
-        .map(core::mem::take)
-        .for_each(drop);
-    }
-
-    /* new_len is less than self.len */
-    self.len = new_len as u16;
-  }
-
-  /// Wraps an array, using the given length as the starting length.
-  ///
-  /// If you want to use the whole length of the array, you can just use the
-  /// `From` impl.
-  ///
-  /// ## Failure
-  ///
-  /// If the given length is greater than the capacity of the array this will
-  /// error, and you'll get the array back in the `Err`.
-  #[inline]
-  #[cfg(not(feature = "latest_stable_rust"))]
-  pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A> {
-    /* Note(Soveu): Should we allow A::CAPACITY > u16::MAX for now? */
-    if len <= A::CAPACITY {
-      Ok(Self { data, len: len as u16 })
-    } else {
-      Err(data)
-    }
-  }
-
-  /// Wraps an array, using the given length as the starting length.
-  ///
-  /// If you want to use the whole length of the array, you can just use the
-  /// `From` impl.
-  ///
-  /// ## Failure
-  ///
-  /// If the given length is greater than the capacity of the array this will
-  /// error, and you'll get the array back in the `Err`.
-  #[inline]
-  #[cfg(feature = "latest_stable_rust")]
-  pub const fn try_from_array_len(data: A, len: usize) -> Result<Self, A> {
-    /* Note(Soveu): Should we allow A::CAPACITY > u16::MAX for now? */
-    if len <= A::CAPACITY {
-      Ok(Self { data, len: len as u16 })
-    } else {
-      Err(data)
-    }
-  }
-}
-
-impl<A> ArrayVec<A> {
-  /// Wraps up an array as a new empty `ArrayVec`.
-  ///
-  /// If you want to simply use the full array, use `from` instead.
-  ///
-  /// ## Examples
-  ///
-  /// This method in particular allows to create values for statics:
-  ///
-  /// ```rust
-  /// # use tinyvec::ArrayVec;
-  /// static DATA: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([0; 5]);
-  /// assert_eq!(DATA.len(), 0);
-  /// ```
-  ///
-  /// But of course it is just an normal empty `ArrayVec`:
-  ///
-  /// ```rust
-  /// # use tinyvec::ArrayVec;
-  /// let mut data = ArrayVec::from_array_empty([1, 2, 3, 4]);
-  /// assert_eq!(&data[..], &[]);
-  /// data.push(42);
-  /// assert_eq!(&data[..], &[42]);
-  /// ```
-  #[inline]
-  #[must_use]
-  pub const fn from_array_empty(data: A) -> Self {
-    Self { data, len: 0 }
-  }
-}
-
-#[cfg(feature = "grab_spare_slice")]
-impl<A: Array> ArrayVec<A> {
-  /// Obtain the shared slice of the array _after_ the active memory.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4]);
-  /// assert_eq!(av.grab_spare_slice().len(), 4);
-  /// av.push(10);
-  /// av.push(11);
-  /// av.push(12);
-  /// av.push(13);
-  /// assert_eq!(av.grab_spare_slice().len(), 0);
-  /// ```
-  #[inline(always)]
-  pub fn grab_spare_slice(&self) -> &[A::Item] {
-    &self.data.as_slice()[self.len as usize..]
-  }
-
-  /// Obtain the mutable slice of the array _after_ the active memory.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 4]);
-  /// assert_eq!(av.grab_spare_slice_mut().len(), 4);
-  /// av.push(10);
-  /// av.push(11);
-  /// assert_eq!(av.grab_spare_slice_mut().len(), 2);
-  /// ```
-  #[inline(always)]
-  pub fn grab_spare_slice_mut(&mut self) -> &mut [A::Item] {
-    &mut self.data.as_slice_mut()[self.len as usize..]
-  }
-}
-
-#[cfg(feature = "nightly_slice_partition_dedup")]
-impl<A: Array> ArrayVec<A> {
-  /// De-duplicates the vec contents.
-  #[inline(always)]
-  pub fn dedup(&mut self)
-  where
-    A::Item: PartialEq,
-  {
-    self.dedup_by(|a, b| a == b)
-  }
-
-  /// De-duplicates the vec according to the predicate given.
-  #[inline(always)]
-  pub fn dedup_by<F>(&mut self, same_bucket: F)
-  where
-    F: FnMut(&mut A::Item, &mut A::Item) -> bool,
-  {
-    let len = {
-      let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket);
-      dedup.len()
-    };
-    self.truncate(len);
-  }
-
-  /// De-duplicates the vec according to the key selector given.
-  #[inline(always)]
-  pub fn dedup_by_key<F, K>(&mut self, mut key: F)
-  where
-    F: FnMut(&mut A::Item) -> K,
-    K: PartialEq,
-  {
-    self.dedup_by(|a, b| key(a) == key(b))
-  }
-}
-
-impl<A> ArrayVec<A> {
-  /// Returns the reference to the inner array of the `ArrayVec`.
-  ///
-  /// This returns the full array, even if the `ArrayVec` length is currently
-  /// less than that.
-  #[inline(always)]
-  #[must_use]
-  pub const fn as_inner(&self) -> &A {
-    &self.data
-  }
-}
-
-/// Splicing iterator for `ArrayVec`
-/// See [`ArrayVec::splice`](ArrayVec::<A>::splice)
-pub struct ArrayVecSplice<'p, A: Array, I: Iterator<Item = A::Item>> {
-  parent: &'p mut ArrayVec<A>,
-  removal_start: usize,
-  removal_end: usize,
-  replacement: I,
-}
-
-impl<'p, A: Array, I: Iterator<Item = A::Item>> Iterator
-  for ArrayVecSplice<'p, A, I>
-{
-  type Item = A::Item;
-
-  #[inline]
-  fn next(&mut self) -> Option<A::Item> {
-    if self.removal_start < self.removal_end {
-      match self.replacement.next() {
-        Some(replacement) => {
-          let removed = core::mem::replace(
-            &mut self.parent[self.removal_start],
-            replacement,
-          );
-          self.removal_start += 1;
-          Some(removed)
-        }
-        None => {
-          let removed = self.parent.remove(self.removal_start);
-          self.removal_end -= 1;
-          Some(removed)
-        }
-      }
-    } else {
-      None
-    }
-  }
-
-  #[inline]
-  fn size_hint(&self) -> (usize, Option<usize>) {
-    let len = self.len();
-    (len, Some(len))
-  }
-}
-
-impl<'p, A, I> ExactSizeIterator for ArrayVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item>,
-{
-  #[inline]
-  fn len(&self) -> usize {
-    self.removal_end - self.removal_start
-  }
-}
-
-impl<'p, A, I> FusedIterator for ArrayVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item>,
-{
-}
-
-impl<'p, A, I> DoubleEndedIterator for ArrayVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item> + DoubleEndedIterator,
-{
-  #[inline]
-  fn next_back(&mut self) -> Option<A::Item> {
-    if self.removal_start < self.removal_end {
-      match self.replacement.next_back() {
-        Some(replacement) => {
-          let removed = core::mem::replace(
-            &mut self.parent[self.removal_end - 1],
-            replacement,
-          );
-          self.removal_end -= 1;
-          Some(removed)
-        }
-        None => {
-          let removed = self.parent.remove(self.removal_end - 1);
-          self.removal_end -= 1;
-          Some(removed)
-        }
-      }
-    } else {
-      None
-    }
-  }
-}
-
-impl<'p, A: Array, I: Iterator<Item = A::Item>> Drop
-  for ArrayVecSplice<'p, A, I>
-{
-  #[inline]
-  fn drop(&mut self) {
-    for _ in self.by_ref() {}
-
-    // FIXME: reserve lower bound of size_hint
-
-    for replacement in self.replacement.by_ref() {
-      self.parent.insert(self.removal_end, replacement);
-      self.removal_end += 1;
-    }
-  }
-}
-
-impl<A: Array> AsMut<[A::Item]> for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn as_mut(&mut self) -> &mut [A::Item] {
-    &mut *self
-  }
-}
-
-impl<A: Array> AsRef<[A::Item]> for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn as_ref(&self) -> &[A::Item] {
-    &*self
-  }
-}
-
-impl<A: Array> Borrow<[A::Item]> for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn borrow(&self) -> &[A::Item] {
-    &*self
-  }
-}
-
-impl<A: Array> BorrowMut<[A::Item]> for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn borrow_mut(&mut self) -> &mut [A::Item] {
-    &mut *self
-  }
-}
-
-impl<A: Array> Extend<A::Item> for ArrayVec<A> {
-  #[inline]
-  fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T) {
-    for t in iter {
-      self.push(t)
-    }
-  }
-}
-
-impl<A: Array> From<A> for ArrayVec<A> {
-  #[inline(always)]
-  #[must_use]
-  /// The output has a length equal to the full array.
-  ///
-  /// If you want to select a length, use
-  /// [`from_array_len`](ArrayVec::from_array_len)
-  fn from(data: A) -> Self {
-    let len: u16 = data
-      .as_slice()
-      .len()
-      .try_into()
-      .expect("ArrayVec::from> length must be in range 0..=u16::MAX");
-    Self { len, data }
-  }
-}
-
-/// The error type returned when a conversion from a slice to an [`ArrayVec`]
-/// fails.
-#[derive(Debug, Copy, Clone)]
-pub struct TryFromSliceError(());
-
-impl core::fmt::Display for TryFromSliceError {
-  #[inline]
-  fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-    f.write_str("could not convert slice to ArrayVec")
-  }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for TryFromSliceError {}
-
-impl<T, A> TryFrom<&'_ [T]> for ArrayVec<A>
-where
-  T: Clone + Default,
-  A: Array<Item = T>,
-{
-  type Error = TryFromSliceError;
-
-  #[inline]
-  /// The output has a length equal to that of the slice, with the same capacity
-  /// as `A`.
-  fn try_from(slice: &[T]) -> Result<Self, Self::Error> {
-    if slice.len() > A::CAPACITY {
-      Err(TryFromSliceError(()))
-    } else {
-      let mut arr = ArrayVec::new();
-      // We do not use ArrayVec::extend_from_slice, because it looks like LLVM
-      // fails to deduplicate all the length-checking logic between the
-      // above if and the contents of that method, thus producing much
-      // slower code. Unlike many of the other optimizations in this
-      // crate, this one is worth keeping an eye on. I see no reason, for
-      // any element type, that these should produce different code. But
-      // they do. (rustc 1.51.0)
-      arr.set_len(slice.len());
-      arr.as_mut_slice().clone_from_slice(slice);
-      Ok(arr)
-    }
-  }
-}
-
-impl<A: Array> FromIterator<A::Item> for ArrayVec<A> {
-  #[inline]
-  #[must_use]
-  fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self {
-    let mut av = Self::default();
-    for i in iter {
-      av.push(i)
-    }
-    av
-  }
-}
-
-/// Iterator for consuming an `ArrayVec` and returning owned elements.
-pub struct ArrayVecIterator<A: Array> {
-  base: u16,
-  tail: u16,
-  data: A,
-}
-
-impl<A: Array> ArrayVecIterator<A> {
-  /// Returns the remaining items of this iterator as a slice.
-  #[inline]
-  #[must_use]
-  pub fn as_slice(&self) -> &[A::Item] {
-    &self.data.as_slice()[self.base as usize..self.tail as usize]
-  }
-}
-impl<A: Array> FusedIterator for ArrayVecIterator<A> {}
-impl<A: Array> Iterator for ArrayVecIterator<A> {
-  type Item = A::Item;
-  #[inline]
-  fn next(&mut self) -> Option<Self::Item> {
-    let slice =
-      &mut self.data.as_slice_mut()[self.base as usize..self.tail as usize];
-    let itemref = slice.first_mut()?;
-    self.base += 1;
-    return Some(core::mem::take(itemref));
-  }
-  #[inline(always)]
-  #[must_use]
-  fn size_hint(&self) -> (usize, Option<usize>) {
-    let s = self.tail - self.base;
-    let s = s as usize;
-    (s, Some(s))
-  }
-  #[inline(always)]
-  fn count(self) -> usize {
-    self.size_hint().0
-  }
-  #[inline]
-  fn last(mut self) -> Option<Self::Item> {
-    self.next_back()
-  }
-  #[inline]
-  fn nth(&mut self, n: usize) -> Option<A::Item> {
-    let slice = &mut self.data.as_slice_mut();
-    let slice = &mut slice[self.base as usize..self.tail as usize];
-
-    if let Some(x) = slice.get_mut(n) {
-      /* n is in range [0 .. self.tail - self.base) so in u16 range */
-      self.base += n as u16 + 1;
-      return Some(core::mem::take(x));
-    }
-
-    self.base = self.tail;
-    return None;
-  }
-}
-
-impl<A: Array> DoubleEndedIterator for ArrayVecIterator<A> {
-  #[inline]
-  fn next_back(&mut self) -> Option<Self::Item> {
-    let slice =
-      &mut self.data.as_slice_mut()[self.base as usize..self.tail as usize];
-    let item = slice.last_mut()?;
-    self.tail -= 1;
-    return Some(core::mem::take(item));
-  }
-
-  #[inline]
-  fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
-    let base = self.base as usize;
-    let tail = self.tail as usize;
-    let slice = &mut self.data.as_slice_mut()[base..tail];
-    let n = n.saturating_add(1);
-
-    if let Some(n) = slice.len().checked_sub(n) {
-      let item = &mut slice[n];
-      /* n is in [0..self.tail - self.base] range, so in u16 range */
-      self.tail = self.base + n as u16;
-      return Some(core::mem::take(item));
-    }
-
-    self.tail = self.base;
-    return None;
-  }
-}
-
-impl<A: Array> ExactSizeIterator for ArrayVecIterator<A> {
-  #[inline]
-  fn len(&self) -> usize {
-    self.size_hint().0
-  }
-}
-
-impl<A: Array> Debug for ArrayVecIterator<A>
-where
-  A::Item: Debug,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-    f.debug_tuple("ArrayVecIterator").field(&self.as_slice()).finish()
-  }
-}
-
-impl<A: Array> IntoIterator for ArrayVec<A> {
-  type Item = A::Item;
-  type IntoIter = ArrayVecIterator<A>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    ArrayVecIterator { base: 0, tail: self.len, data: self.data }
-  }
-}
-
-impl<'a, A: Array> IntoIterator for &'a mut ArrayVec<A> {
-  type Item = &'a mut A::Item;
-  type IntoIter = core::slice::IterMut<'a, A::Item>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    self.iter_mut()
-  }
-}
-
-impl<'a, A: Array> IntoIterator for &'a ArrayVec<A> {
-  type Item = &'a A::Item;
-  type IntoIter = core::slice::Iter<'a, A::Item>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    self.iter()
-  }
-}
-
-impl<A: Array> PartialEq for ArrayVec<A>
-where
-  A::Item: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &Self) -> bool {
-    self.as_slice().eq(other.as_slice())
-  }
-}
-impl<A: Array> Eq for ArrayVec<A> where A::Item: Eq {}
-
-impl<A: Array> PartialOrd for ArrayVec<A>
-where
-  A::Item: PartialOrd,
-{
-  #[inline]
-  #[must_use]
-  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-    self.as_slice().partial_cmp(other.as_slice())
-  }
-}
-impl<A: Array> Ord for ArrayVec<A>
-where
-  A::Item: Ord,
-{
-  #[inline]
-  #[must_use]
-  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
-    self.as_slice().cmp(other.as_slice())
-  }
-}
-
-impl<A: Array> PartialEq<&A> for ArrayVec<A>
-where
-  A::Item: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &&A) -> bool {
-    self.as_slice().eq(other.as_slice())
-  }
-}
-
-impl<A: Array> PartialEq<&[A::Item]> for ArrayVec<A>
-where
-  A::Item: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &&[A::Item]) -> bool {
-    self.as_slice().eq(*other)
-  }
-}
-
-impl<A: Array> Hash for ArrayVec<A>
-where
-  A::Item: Hash,
-{
-  #[inline]
-  fn hash<H: Hasher>(&self, state: &mut H) {
-    self.as_slice().hash(state)
-  }
-}
-
-#[cfg(feature = "experimental_write_impl")]
-impl<A: Array<Item = u8>> core::fmt::Write for ArrayVec<A> {
-  fn write_str(&mut self, s: &str) -> core::fmt::Result {
-    let my_len = self.len();
-    let str_len = s.as_bytes().len();
-    if my_len + str_len <= A::CAPACITY {
-      let remainder = &mut self.data.as_slice_mut()[my_len..];
-      let target = &mut remainder[..str_len];
-      target.copy_from_slice(s.as_bytes());
-      Ok(())
-    } else {
-      Err(core::fmt::Error)
-    }
-  }
-}
-
-// // // // // // // //
-// Formatting impls
-// // // // // // // //
-
-impl<A: Array> Binary for ArrayVec<A>
-where
-  A::Item: Binary,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Binary::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Debug for ArrayVec<A>
-where
-  A::Item: Debug,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() && !self.is_empty() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Debug::fmt(elem, f)?;
-    }
-    if f.alternate() && !self.is_empty() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Display for ArrayVec<A>
-where
-  A::Item: Display,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Display::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> LowerExp for ArrayVec<A>
-where
-  A::Item: LowerExp,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      LowerExp::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> LowerHex for ArrayVec<A>
-where
-  A::Item: LowerHex,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      LowerHex::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Octal for ArrayVec<A>
-where
-  A::Item: Octal,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Octal::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Pointer for ArrayVec<A>
-where
-  A::Item: Pointer,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Pointer::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> UpperExp for ArrayVec<A>
-where
-  A::Item: UpperExp,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      UpperExp::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> UpperHex for ArrayVec<A>
-where
-  A::Item: UpperHex,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      UpperHex::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
-
-#[cfg(all(feature = "alloc", feature = "rustc_1_57"))]
-use alloc::collections::TryReserveError;
-
-#[cfg(feature = "alloc")]
-impl<A: Array> ArrayVec<A> {
-  /// Drains all elements to a Vec, but reserves additional space
-  /// ```
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 7] => 1, 2, 3);
-  /// let v = av.drain_to_vec_and_reserve(10);
-  /// assert_eq!(v, &[1, 2, 3]);
-  /// assert_eq!(v.capacity(), 13);
-  /// ```
-  #[inline]
-  pub fn drain_to_vec_and_reserve(&mut self, n: usize) -> Vec<A::Item> {
-    let cap = n + self.len();
-    let mut v = Vec::with_capacity(cap);
-    let iter = self.iter_mut().map(core::mem::take);
-    v.extend(iter);
-    self.set_len(0);
-    return v;
-  }
-
-  /// Tries to drain all elements to a Vec, but reserves additional space.
-  ///
-  /// # Errors
-  ///
-  /// If the allocator reports a failure, then an error is returned.
-  ///
-  /// ```
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 7] => 1, 2, 3);
-  /// let v = av.try_drain_to_vec_and_reserve(10);
-  /// assert!(matches!(v, Ok(_)));
-  /// let v = v.unwrap();
-  /// assert_eq!(v, &[1, 2, 3]);
-  /// assert_eq!(v.capacity(), 13);
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_57")]
-  pub fn try_drain_to_vec_and_reserve(
-    &mut self, n: usize,
-  ) -> Result<Vec<A::Item>, TryReserveError> {
-    let cap = n + self.len();
-    let mut v = Vec::new();
-    v.try_reserve(cap)?;
-    let iter = self.iter_mut().map(core::mem::take);
-    v.extend(iter);
-    self.set_len(0);
-    return Ok(v);
-  }
-
-  /// Drains all elements to a Vec
-  /// ```
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 7] => 1, 2, 3);
-  /// let v = av.drain_to_vec();
-  /// assert_eq!(v, &[1, 2, 3]);
-  /// assert_eq!(v.capacity(), 3);
-  /// ```
-  #[inline]
-  pub fn drain_to_vec(&mut self) -> Vec<A::Item> {
-    self.drain_to_vec_and_reserve(0)
-  }
-
-  /// Tries to drain all elements to a Vec.
-  ///
-  /// # Errors
-  ///
-  /// If the allocator reports a failure, then an error is returned.
-  ///
-  /// ```
-  /// # use tinyvec::*;
-  /// let mut av = array_vec!([i32; 7] => 1, 2, 3);
-  /// let v = av.try_drain_to_vec();
-  /// assert!(matches!(v, Ok(_)));
-  /// let v = v.unwrap();
-  /// assert_eq!(v, &[1, 2, 3]);
-  /// // Vec may reserve more than necessary in order to prevent more future allocations.
-  /// assert!(v.capacity() >= 3);
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_57")]
-  pub fn try_drain_to_vec(&mut self) -> Result<Vec<A::Item>, TryReserveError> {
-    self.try_drain_to_vec_and_reserve(0)
-  }
-}
-
-#[cfg(feature = "serde")]
-struct ArrayVecVisitor<A: Array>(PhantomData<A>);
-
-#[cfg(feature = "serde")]
-impl<'de, A: Array> Visitor<'de> for ArrayVecVisitor<A>
-where
-  A::Item: Deserialize<'de>,
-{
-  type Value = ArrayVec<A>;
-
-  fn expecting(
-    &self, formatter: &mut core::fmt::Formatter,
-  ) -> core::fmt::Result {
-    formatter.write_str("a sequence")
-  }
-
-  fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
-  where
-    S: SeqAccess<'de>,
-  {
-    let mut new_arrayvec: ArrayVec<A> = Default::default();
-
-    let mut idx = 0usize;
-    while let Some(value) = seq.next_element()? {
-      if new_arrayvec.len() >= new_arrayvec.capacity() {
-        return Err(DeserializeError::invalid_length(idx, &self));
-      }
-      new_arrayvec.push(value);
-      idx = idx + 1;
-    }
-
-    Ok(new_arrayvec)
-  }
-}
-
-#[cfg(test)]
-mod test {
-  use super::*;
-
-  #[test]
-  fn retain_mut_empty_vec() {
-    let mut av: ArrayVec<[i32; 4]> = ArrayVec::new();
-    av.retain_mut(|&mut x| x % 2 == 0);
-    assert_eq!(av.len(), 0);
-  }
-
-  #[test]
-  fn retain_mut_all_elements() {
-    let mut av: ArrayVec<[i32; 4]> = array_vec!([i32; 4] => 2, 4, 6, 8);
-    av.retain_mut(|&mut x| x % 2 == 0);
-    assert_eq!(av.len(), 4);
-    assert_eq!(av.as_slice(), &[2, 4, 6, 8]);
-  }
-
-  #[test]
-  fn retain_mut_some_elements() {
-    let mut av: ArrayVec<[i32; 4]> = array_vec!([i32; 4] => 1, 2, 3, 4);
-    av.retain_mut(|&mut x| x % 2 == 0);
-    assert_eq!(av.len(), 2);
-    assert_eq!(av.as_slice(), &[2, 4]);
-  }
-
-  #[test]
-  fn retain_mut_no_elements() {
-    let mut av: ArrayVec<[i32; 4]> = array_vec!([i32; 4] => 1, 3, 5, 7);
-    av.retain_mut(|&mut x| x % 2 == 0);
-    assert_eq!(av.len(), 0);
-  }
-
-  #[test]
-  fn retain_mut_zero_capacity() {
-    let mut av: ArrayVec<[i32; 0]> = ArrayVec::new();
-    av.retain_mut(|&mut x| x % 2 == 0);
-    assert_eq!(av.len(), 0);
-  }
-}
diff --git a/third_party/rust/tinyvec/src/arrayvec_drain.rs b/third_party/rust/tinyvec/src/arrayvec_drain.rs
@@ -1,99 +0,0 @@
-use super::*;
-
-use core::{
-  ops::{Bound, RangeBounds},
-  slice,
-};
-
-/// Draining iterator for [`ArrayVec`]
-///
-/// See [`ArrayVec::drain`](ArrayVec::drain)
-pub struct ArrayVecDrain<'a, T: 'a + Default> {
-  iter: slice::IterMut<'a, T>,
-}
-
-impl<'a, T: 'a + Default> ArrayVecDrain<'a, T> {
-  pub(crate) fn new<A, R>(arr: &'a mut ArrayVec<A>, range: R) -> Self
-  where
-    A: Array<Item = T>,
-    R: RangeBounds<usize>,
-  {
-    let start = match range.start_bound() {
-      Bound::Unbounded => 0,
-      Bound::Included(&n) => n,
-      Bound::Excluded(&n) => n.saturating_add(1),
-    };
-    let end = match range.end_bound() {
-      Bound::Unbounded => arr.len(),
-      Bound::Included(&n) => n.saturating_add(1),
-      Bound::Excluded(&n) => n,
-    };
-
-    assert!(
-      start <= end,
-      "ArrayVec::drain> Illegal range, {} to {}",
-      start,
-      end
-    );
-    assert!(
-      end <= arr.len(),
-      "ArrayVec::drain> Range ends at {}, but length is only {}",
-      end,
-      arr.len()
-    );
-
-    let len = end - start;
-    let to_rotate = &mut arr[start..];
-    to_rotate.rotate_left(len);
-
-    let oldlen = arr.len();
-    let newlen = oldlen - len;
-    arr.set_len(newlen);
-    let slice = &mut arr.data.as_slice_mut()[newlen..oldlen];
-    let iter = slice.iter_mut();
-    Self { iter }
-  }
-}
-
-impl<'a, T: 'a + Default> DoubleEndedIterator for ArrayVecDrain<'a, T> {
-  #[inline]
-  fn next_back(&mut self) -> Option<Self::Item> {
-    self.iter.next_back().map(core::mem::take)
-  }
-
-  #[inline]
-  fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
-    self.iter.nth_back(n).map(core::mem::take)
-  }
-}
-
-impl<'a, T: 'a + Default> Iterator for ArrayVecDrain<'a, T> {
-  type Item = T;
-  #[inline]
-  fn next(&mut self) -> Option<Self::Item> {
-    self.iter.next().map(core::mem::take)
-  }
-  #[inline]
-  fn size_hint(&self) -> (usize, Option<usize>) {
-    self.iter.size_hint()
-  }
-  #[inline]
-  fn nth(&mut self, n: usize) -> Option<Self::Item> {
-    self.iter.nth(n).map(core::mem::take)
-  }
-  #[inline]
-  fn last(self) -> Option<Self::Item> {
-    self.iter.last().map(core::mem::take)
-  }
-  #[inline]
-  fn for_each<F>(self, f: F)
-  where
-    F: FnMut(Self::Item),
-  {
-    self.iter.map(core::mem::take).for_each(f)
-  }
-}
-
-impl<'a, T: 'a + Default> FusedIterator for ArrayVecDrain<'a, T> {}
-impl<'a, T: 'a + Default> ExactSizeIterator for ArrayVecDrain<'a, T> {}
-/* No need to impl Drop! */
diff --git a/third_party/rust/tinyvec/src/lib.rs b/third_party/rust/tinyvec/src/lib.rs
@@ -1,112 +0,0 @@
-#![cfg_attr(not(feature = "std"), no_std)]
-#![forbid(unsafe_code)]
-#![cfg_attr(
-  feature = "nightly_slice_partition_dedup",
-  feature(slice_partition_dedup)
-)]
-#![cfg_attr(
-  feature = "debugger_visualizer",
-  feature(debugger_visualizer),
-  debugger_visualizer(natvis_file = "../debug_metadata/tinyvec.natvis")
-)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![warn(clippy::missing_inline_in_public_items)]
-#![warn(clippy::must_use_candidate)]
-#![warn(missing_docs)]
-#![allow(clippy::borrow_deref_ref)]
-#![allow(unused_imports)]
-#![allow(unused_mut)]
-#![allow(clippy::write_with_newline)]
-#![allow(clippy::needless_return)]
-
-//! `tinyvec` provides 100% safe vec-like data structures.
-//!
-//! ## Provided Types
-//! With no features enabled, this crate provides the [`ArrayVec`] type, which
-//! is an array-backed storage. You can push values into the array and pop them
-//! out of the array and so on. If the array is made to overflow it will panic.
-//!
-//! Similarly, there is also a [`SliceVec`] type available, which is a vec-like
-//! that's backed by a slice you provide. You can add and remove elements, but
-//! if you overflow the slice it will panic.
-//!
-//! With the `alloc` feature enabled, the crate also has a [`TinyVec`] type.
-//! This is an enum type which is either an `Inline(ArrayVec)` or a `Heap(Vec)`.
-//! If a `TinyVec` is `Inline` and would overflow it automatically transitions
-//! itself into being `Heap` mode instead of a panic.
-//!
-//! All of this is done with no `unsafe` code within the crate. Technically the
-//! `Vec` type from the standard library uses `unsafe` internally, but *this
-//! crate* introduces no new `unsafe` code into your project.
-//!
-//! The limitation is that the element type of a vec from this crate must
-//! support the [`Default`] trait. This means that this crate isn't suitable for
-//! all situations, but a very surprising number of types do support `Default`.
-//!
-//! ## Other Features
-//! * `grab_spare_slice` lets you get access to the "inactive" portions of an
-//!   ArrayVec.
-//! * `serde` provides a `Serialize` and `Deserialize` implementation for
-//!   [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has an
-//!   implementation.
-//! * `borsh` provides a `BorshSerialize` and `BorshDeserialize` implementation
-//!   for [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has
-//!   an implementation.
-//!
-//! ## API
-//! The general goal of the crate is that, as much as possible, the vecs here
-//! should be a "drop in" replacement for the standard library `Vec` type. We
-//! strive to provide all of the `Vec` methods with the same names and
-//! signatures. The exception is that the element type of some methods will have
-//! a `Default` bound that's not part of the normal `Vec` type.
-//!
-//! The vecs here also have a few additional methods that aren't on the `Vec`
-//! type. In this case, the names tend to be fairly long so that they are
-//! unlikely to clash with any future methods added to `Vec`.
-//!
-//! ## Stability
-//! * The `1.0` series of the crate works with Rustc `1.34.0` or later, though
-//!   you still need to have Rustc `1.36.0` to use the `alloc` feature.
-//! * The `2.0` version of the crate is planned for some time after the
-//!   `min_const_generics` stuff becomes stable. This would greatly raise the
-//!   minimum rust version and also allow us to totally eliminate the need for
-//!   the `Array` trait. The actual usage of the crate is not expected to break
-//!   significantly in this transition.
-
-#[allow(unused_imports)]
-use core::{
-  borrow::{Borrow, BorrowMut},
-  cmp::PartialEq,
-  convert::AsMut,
-  default::Default,
-  fmt::{
-    Binary, Debug, Display, Formatter, LowerExp, LowerHex, Octal, Pointer,
-    UpperExp, UpperHex,
-  },
-  hash::{Hash, Hasher},
-  iter::{Extend, FromIterator, FusedIterator, IntoIterator, Iterator},
-  mem::{needs_drop, replace},
-  ops::{Deref, DerefMut, Index, IndexMut, RangeBounds},
-  slice::SliceIndex,
-};
-
-#[cfg(feature = "alloc")]
-#[doc(hidden)] // re-export for macros
-pub extern crate alloc;
-
-mod array;
-pub use array::*;
-
-mod arrayvec;
-pub use arrayvec::*;
-
-mod arrayvec_drain;
-pub use arrayvec_drain::*;
-
-mod slicevec;
-pub use slicevec::*;
-
-#[cfg(feature = "alloc")]
-mod tinyvec;
-#[cfg(feature = "alloc")]
-pub use crate::tinyvec::*;
diff --git a/third_party/rust/tinyvec/src/slicevec.rs b/third_party/rust/tinyvec/src/slicevec.rs
@@ -1,1083 +0,0 @@
-#![allow(unused_variables)]
-#![allow(missing_docs)]
-
-use super::*;
-
-/// A slice-backed vector-like data structure.
-///
-/// This is a very similar concept to `ArrayVec`, but instead
-/// of the backing memory being an owned array, the backing
-/// memory is a unique-borrowed slice. You can thus create
-/// one of these structures "around" some slice that you're
-/// working with to make it easier to manipulate.
-///
-/// * Has a fixed capacity (the initial slice size).
-/// * Has a variable length.
-pub struct SliceVec<'s, T> {
-  data: &'s mut [T],
-  len: usize,
-}
-
-impl<'s, T> Default for SliceVec<'s, T> {
-  #[inline(always)]
-  #[must_use]
-  fn default() -> Self {
-    Self { data: &mut [], len: 0 }
-  }
-}
-
-impl<'s, T> Deref for SliceVec<'s, T> {
-  type Target = [T];
-  #[inline(always)]
-  #[must_use]
-  fn deref(&self) -> &Self::Target {
-    &self.data[..self.len]
-  }
-}
-
-impl<'s, T> DerefMut for SliceVec<'s, T> {
-  #[inline(always)]
-  #[must_use]
-  fn deref_mut(&mut self) -> &mut Self::Target {
-    &mut self.data[..self.len]
-  }
-}
-
-impl<'s, T, I> Index<I> for SliceVec<'s, T>
-where
-  I: SliceIndex<[T]>,
-{
-  type Output = <I as SliceIndex<[T]>>::Output;
-  #[inline(always)]
-  #[must_use]
-  fn index(&self, index: I) -> &Self::Output {
-    &self.deref()[index]
-  }
-}
-
-impl<'s, T, I> IndexMut<I> for SliceVec<'s, T>
-where
-  I: SliceIndex<[T]>,
-{
-  #[inline(always)]
-  #[must_use]
-  fn index_mut(&mut self, index: I) -> &mut Self::Output {
-    &mut self.deref_mut()[index]
-  }
-}
-
-impl<'s, T> SliceVec<'s, T> {
-  #[inline]
-  pub fn append(&mut self, other: &mut Self)
-  where
-    T: Default,
-  {
-    for item in other.drain(..) {
-      self.push(item)
-    }
-  }
-
-  /// A `*mut` pointer to the backing slice.
-  ///
-  /// ## Safety
-  ///
-  /// This pointer has provenance over the _entire_ backing slice.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_mut_ptr(&mut self) -> *mut T {
-    self.data.as_mut_ptr()
-  }
-
-  /// Performs a `deref_mut`, into unique slice form.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_mut_slice(&mut self) -> &mut [T] {
-    self.deref_mut()
-  }
-
-  /// A `*const` pointer to the backing slice.
-  ///
-  /// ## Safety
-  ///
-  /// This pointer has provenance over the _entire_ backing slice.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_ptr(&self) -> *const T {
-    self.data.as_ptr()
-  }
-
-  /// Performs a `deref`, into shared slice form.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_slice(&self) -> &[T] {
-    self.deref()
-  }
-
-  /// The capacity of the `SliceVec`.
-  ///
-  /// This the length of the initial backing slice.
-  #[inline(always)]
-  #[must_use]
-  pub fn capacity(&self) -> usize {
-    self.data.len()
-  }
-
-  /// Truncates the `SliceVec` down to length 0.
-  #[inline(always)]
-  pub fn clear(&mut self)
-  where
-    T: Default,
-  {
-    self.truncate(0)
-  }
-
-  /// Creates a draining iterator that removes the specified range in the vector
-  /// and yields the removed items.
-  ///
-  /// ## Panics
-  /// * If the start is greater than the end
-  /// * If the end is past the edge of the vec.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [6, 7, 8];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// let drained_values: ArrayVec<[i32; 4]> = sv.drain(1..).collect();
-  /// assert_eq!(sv.as_slice(), &[6][..]);
-  /// assert_eq!(drained_values.as_slice(), &[7, 8][..]);
-  ///
-  /// sv.drain(..);
-  /// assert_eq!(sv.as_slice(), &[]);
-  /// ```
-  #[inline]
-  pub fn drain<'p, R: RangeBounds<usize>>(
-    &'p mut self, range: R,
-  ) -> SliceVecDrain<'p, 's, T>
-  where
-    T: Default,
-  {
-    use core::ops::Bound;
-    let start = match range.start_bound() {
-      Bound::Included(x) => *x,
-      Bound::Excluded(x) => x.saturating_add(1),
-      Bound::Unbounded => 0,
-    };
-    let end = match range.end_bound() {
-      Bound::Included(x) => x.saturating_add(1),
-      Bound::Excluded(x) => *x,
-      Bound::Unbounded => self.len,
-    };
-    assert!(
-      start <= end,
-      "SliceVec::drain> Illegal range, {} to {}",
-      start,
-      end
-    );
-    assert!(
-      end <= self.len,
-      "SliceVec::drain> Range ends at {} but length is only {}!",
-      end,
-      self.len
-    );
-    SliceVecDrain {
-      parent: self,
-      target_start: start,
-      target_index: start,
-      target_end: end,
-    }
-  }
-
-  #[inline]
-  pub fn extend_from_slice(&mut self, sli: &[T])
-  where
-    T: Clone,
-  {
-    if sli.is_empty() {
-      return;
-    }
-
-    let new_len = self.len + sli.len();
-    if new_len > self.capacity() {
-      panic!(
-        "SliceVec::extend_from_slice> total length {} exceeds capacity {}",
-        new_len,
-        self.capacity()
-      )
-    }
-
-    let target = &mut self.data[self.len..new_len];
-    target.clone_from_slice(sli);
-    self.set_len(new_len);
-  }
-
-  /// Fill the vector until its capacity has been reached.
-  ///
-  /// Successively fills unused space in the spare slice of the vector with
-  /// elements from the iterator. It then returns the remaining iterator
-  /// without exhausting it. This also allows appending the head of an
-  /// infinite iterator.
-  ///
-  /// This is an alternative to `Extend::extend` method for cases where the
-  /// length of the iterator can not be checked. Since this vector can not
-  /// reallocate to increase its capacity, it is unclear what to do with
-  /// remaining elements in the iterator and the iterator itself. The
-  /// interface also provides no way to communicate this to the caller.
-  ///
-  /// ## Panics
-  /// * If the `next` method of the provided iterator panics.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [7, 7, 7, 7];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
-  /// let mut to_inf = sv.fill(0..);
-  /// assert_eq!(&sv[..], [0, 1, 2, 3]);
-  /// assert_eq!(to_inf.next(), Some(4));
-  /// ```
-  #[inline]
-  pub fn fill<I: IntoIterator<Item = T>>(&mut self, iter: I) -> I::IntoIter {
-    let mut iter = iter.into_iter();
-    for element in iter.by_ref().take(self.capacity() - self.len()) {
-      self.push(element);
-    }
-    iter
-  }
-
-  /// Wraps up a slice and uses the given length as the initial length.
-  ///
-  /// If you want to simply use the full slice, use `from` instead.
-  ///
-  /// ## Panics
-  ///
-  /// * The length specified must be less than or equal to the capacity of the
-  ///   slice.
-  #[inline]
-  #[must_use]
-  #[allow(clippy::match_wild_err_arm)]
-  pub fn from_slice_len(data: &'s mut [T], len: usize) -> Self {
-    assert!(len <= data.len());
-    Self { data, len }
-  }
-
-  /// Inserts an item at the position given, moving all following elements +1
-  /// index.
-  ///
-  /// ## Panics
-  /// * If `index` > `len`
-  /// * If the capacity is exhausted
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [1, 2, 3, 0, 0];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
-  /// sv.insert(1, 4);
-  /// assert_eq!(sv.as_slice(), &[1, 4, 2, 3]);
-  /// sv.insert(4, 5);
-  /// assert_eq!(sv.as_slice(), &[1, 4, 2, 3, 5]);
-  /// ```
-  #[inline]
-  pub fn insert(&mut self, index: usize, item: T) {
-    if index > self.len {
-      panic!("SliceVec::insert> index {} is out of bounds {}", index, self.len);
-    }
-
-    // Try to push the element.
-    self.push(item);
-    // And move it into its place.
-    self.as_mut_slice()[index..].rotate_right(1);
-  }
-
-  /// Checks if the length is 0.
-  #[inline(always)]
-  #[must_use]
-  pub fn is_empty(&self) -> bool {
-    self.len == 0
-  }
-
-  /// The length of the `SliceVec` (in elements).
-  #[inline(always)]
-  #[must_use]
-  pub fn len(&self) -> usize {
-    self.len
-  }
-
-  /// Remove and return the last element of the vec, if there is one.
-  ///
-  /// ## Failure
-  /// * If the vec is empty you get `None`.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [1, 2];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// assert_eq!(sv.pop(), Some(2));
-  /// assert_eq!(sv.pop(), Some(1));
-  /// assert_eq!(sv.pop(), None);
-  /// ```
-  #[inline]
-  pub fn pop(&mut self) -> Option<T>
-  where
-    T: Default,
-  {
-    if self.len > 0 {
-      self.len -= 1;
-      let out = core::mem::take(&mut self.data[self.len]);
-      Some(out)
-    } else {
-      None
-    }
-  }
-
-  /// Place an element onto the end of the vec.
-  ///
-  /// ## Panics
-  /// * If the length of the vec would overflow the capacity.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [0, 0];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
-  /// assert_eq!(&sv[..], []);
-  /// sv.push(1);
-  /// assert_eq!(&sv[..], [1]);
-  /// sv.push(2);
-  /// assert_eq!(&sv[..], [1, 2]);
-  /// // sv.push(3); this would overflow the ArrayVec and panic!
-  /// ```
-  #[inline(always)]
-  pub fn push(&mut self, val: T) {
-    if self.len < self.capacity() {
-      self.data[self.len] = val;
-      self.len += 1;
-    } else {
-      panic!("SliceVec::push> capacity overflow")
-    }
-  }
-
-  /// Removes the item at `index`, shifting all others down by one index.
-  ///
-  /// Returns the removed element.
-  ///
-  /// ## Panics
-  ///
-  /// * If the index is out of bounds.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [1, 2, 3];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// assert_eq!(sv.remove(1), 2);
-  /// assert_eq!(&sv[..], [1, 3]);
-  /// ```
-  #[inline]
-  pub fn remove(&mut self, index: usize) -> T
-  where
-    T: Default,
-  {
-    let targets: &mut [T] = &mut self.deref_mut()[index..];
-    let item = core::mem::take(&mut targets[0]);
-    targets.rotate_left(1);
-    self.len -= 1;
-    item
-  }
-
-  /// As [`resize_with`](SliceVec::resize_with)
-  /// and it clones the value as the closure.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// // bigger
-  /// let mut arr = ["hello", "", "", "", ""];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 1);
-  /// sv.resize(3, "world");
-  /// assert_eq!(&sv[..], ["hello", "world", "world"]);
-  ///
-  /// // smaller
-  /// let mut arr = ['a', 'b', 'c', 'd'];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// sv.resize(2, 'z');
-  /// assert_eq!(&sv[..], ['a', 'b']);
-  /// ```
-  #[inline]
-  pub fn resize(&mut self, new_len: usize, new_val: T)
-  where
-    T: Clone,
-  {
-    self.resize_with(new_len, || new_val.clone())
-  }
-
-  /// Resize the vec to the new length.
-  ///
-  /// * If it needs to be longer, it's filled with repeated calls to the
-  ///   provided function.
-  /// * If it needs to be shorter, it's truncated.
-  ///   * If the type needs to drop the truncated slots are filled with calls to
-  ///     the provided function.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [1, 2, 3, 7, 7, 7, 7];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 3);
-  /// sv.resize_with(5, Default::default);
-  /// assert_eq!(&sv[..], [1, 2, 3, 0, 0]);
-  ///
-  /// let mut arr = [0, 0, 0, 0];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
-  /// let mut p = 1;
-  /// sv.resize_with(4, || {
-  ///   p *= 2;
-  ///   p
-  /// });
-  /// assert_eq!(&sv[..], [2, 4, 8, 16]);
-  /// ```
-  #[inline]
-  pub fn resize_with<F: FnMut() -> T>(&mut self, new_len: usize, mut f: F) {
-    match new_len.checked_sub(self.len) {
-      None => {
-        if needs_drop::<T>() {
-          while self.len() > new_len {
-            self.len -= 1;
-            self.data[self.len] = f();
-          }
-        } else {
-          self.len = new_len;
-        }
-      }
-      Some(new_elements) => {
-        for _ in 0..new_elements {
-          self.push(f());
-        }
-      }
-    }
-  }
-
-  /// Walk the vec and keep only the elements that pass the predicate given.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  ///
-  /// let mut arr = [1, 1, 2, 3, 3, 4];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// sv.retain(|&x| x % 2 == 0);
-  /// assert_eq!(&sv[..], [2, 4]);
-  /// ```
-  #[inline]
-  pub fn retain<F: FnMut(&T) -> bool>(&mut self, mut acceptable: F)
-  where
-    T: Default,
-  {
-    // Drop guard to contain exactly the remaining elements when the test
-    // panics.
-    struct JoinOnDrop<'vec, Item> {
-      items: &'vec mut [Item],
-      done_end: usize,
-      // Start of tail relative to `done_end`.
-      tail_start: usize,
-    }
-
-    impl<Item> Drop for JoinOnDrop<'_, Item> {
-      fn drop(&mut self) {
-        self.items[self.done_end..].rotate_left(self.tail_start);
-      }
-    }
-
-    let mut rest = JoinOnDrop { items: self.data, done_end: 0, tail_start: 0 };
-
-    for idx in 0..self.len {
-      // Loop start invariant: idx = rest.done_end + rest.tail_start
-      if !acceptable(&rest.items[idx]) {
-        let _ = core::mem::take(&mut rest.items[idx]);
-        self.len -= 1;
-        rest.tail_start += 1;
-      } else {
-        rest.items.swap(rest.done_end, idx);
-        rest.done_end += 1;
-      }
-    }
-  }
-
-  /// Forces the length of the vector to `new_len`.
-  ///
-  /// ## Panics
-  /// * If `new_len` is greater than the vec's capacity.
-  ///
-  /// ## Safety
-  /// * This is a fully safe operation! The inactive memory already counts as
-  ///   "initialized" by Rust's rules.
-  /// * Other than "the memory is initialized" there are no other guarantees
-  ///   regarding what you find in the inactive portion of the vec.
-  #[inline(always)]
-  pub fn set_len(&mut self, new_len: usize) {
-    if new_len > self.capacity() {
-      // Note(Lokathor): Technically we don't have to panic here, and we could
-      // just let some other call later on trigger a panic on accident when the
-      // length is wrong. However, it's a lot easier to catch bugs when things
-      // are more "fail-fast".
-      panic!(
-        "SliceVec::set_len> new length {} exceeds capacity {}",
-        new_len,
-        self.capacity()
-      )
-    } else {
-      self.len = new_len;
-    }
-  }
-
-  /// Splits the collection at the point given.
-  ///
-  /// * `[0, at)` stays in this vec (and this vec is now full).
-  /// * `[at, len)` ends up in the new vec (with any spare capacity).
-  ///
-  /// ## Panics
-  /// * if `at` > `self.len()`
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [1, 2, 3];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// let sv2 = sv.split_off(1);
-  /// assert_eq!(&sv[..], [1]);
-  /// assert_eq!(&sv2[..], [2, 3]);
-  /// ```
-  #[inline]
-  pub fn split_off<'a>(&'a mut self, at: usize) -> SliceVec<'s, T> {
-    let mut new = Self::default();
-    let backing: &'s mut [T] = core::mem::take(&mut self.data);
-    let (me, other) = backing.split_at_mut(at);
-    new.len = self.len - at;
-    new.data = other;
-    self.len = me.len();
-    self.data = me;
-    new
-  }
-
-  /// Remove an element, swapping the end of the vec into its place.
-  ///
-  /// ## Panics
-  /// * If the index is out of bounds.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = ["foo", "bar", "quack", "zap"];
-  /// let mut sv = SliceVec::from(&mut arr);
-  ///
-  /// assert_eq!(sv.swap_remove(1), "bar");
-  /// assert_eq!(&sv[..], ["foo", "zap", "quack"]);
-  ///
-  /// assert_eq!(sv.swap_remove(0), "foo");
-  /// assert_eq!(&sv[..], ["quack", "zap"]);
-  /// ```
-  #[inline]
-  pub fn swap_remove(&mut self, index: usize) -> T
-  where
-    T: Default,
-  {
-    assert!(
-      index < self.len,
-      "SliceVec::swap_remove> index {} is out of bounds {}",
-      index,
-      self.len
-    );
-    if index == self.len - 1 {
-      self.pop().unwrap()
-    } else {
-      let i = self.pop().unwrap();
-      replace(&mut self[index], i)
-    }
-  }
-
-  /// Reduces the vec's length to the given value.
-  ///
-  /// If the vec is already shorter than the input, nothing happens.
-  #[inline]
-  pub fn truncate(&mut self, new_len: usize)
-  where
-    T: Default,
-  {
-    if needs_drop::<T>() {
-      while self.len > new_len {
-        self.pop();
-      }
-    } else {
-      self.len = self.len.min(new_len);
-    }
-  }
-
-  /// Wraps a slice, using the given length as the starting length.
-  ///
-  /// If you want to use the whole length of the slice, you can just use the
-  /// `From` impl.
-  ///
-  /// ## Failure
-  ///
-  /// If the given length is greater than the length of the slice you get
-  /// `None`.
-  #[inline]
-  pub fn try_from_slice_len(data: &'s mut [T], len: usize) -> Option<Self> {
-    if len <= data.len() {
-      Some(Self { data, len })
-    } else {
-      None
-    }
-  }
-}
-
-#[cfg(feature = "grab_spare_slice")]
-impl<'s, T> SliceVec<'s, T> {
-  /// Obtain the shared slice of the array _after_ the active memory.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [0; 4];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
-  /// assert_eq!(sv.grab_spare_slice().len(), 4);
-  /// sv.push(10);
-  /// sv.push(11);
-  /// sv.push(12);
-  /// sv.push(13);
-  /// assert_eq!(sv.grab_spare_slice().len(), 0);
-  /// ```
-  #[must_use]
-  #[inline(always)]
-  pub fn grab_spare_slice(&self) -> &[T] {
-    &self.data[self.len..]
-  }
-
-  /// Obtain the mutable slice of the array _after_ the active memory.
-  ///
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [0; 4];
-  /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
-  /// assert_eq!(sv.grab_spare_slice_mut().len(), 4);
-  /// sv.push(10);
-  /// sv.push(11);
-  /// assert_eq!(sv.grab_spare_slice_mut().len(), 2);
-  /// ```
-  #[inline(always)]
-  pub fn grab_spare_slice_mut(&mut self) -> &mut [T] {
-    &mut self.data[self.len..]
-  }
-}
-
-impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T> {
-  /// Uses the full slice as the initial length.
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [0_i32; 2];
-  /// let mut sv = SliceVec::from(&mut arr[..]);
-  /// ```
-  #[inline]
-  fn from(data: &'s mut [T]) -> Self {
-    let len = data.len();
-    Self { data, len }
-  }
-}
-
-impl<'s, T, A> From<&'s mut A> for SliceVec<'s, T>
-where
-  A: AsMut<[T]>,
-{
-  /// Calls `AsRef::as_mut` then uses the full slice as the initial length.
-  /// ## Example
-  /// ```rust
-  /// # use tinyvec::*;
-  /// let mut arr = [0, 0];
-  /// let mut sv = SliceVec::from(&mut arr);
-  /// ```
-  #[inline]
-  fn from(a: &'s mut A) -> Self {
-    let data = a.as_mut();
-    let len = data.len();
-    Self { data, len }
-  }
-}
-
-/// Draining iterator for [`SliceVec`]
-///
-/// See [`SliceVec::drain`](SliceVec::drain)
-pub struct SliceVecDrain<'p, 's, T: Default> {
-  parent: &'p mut SliceVec<'s, T>,
-  target_start: usize,
-  target_index: usize,
-  target_end: usize,
-}
-impl<'p, 's, T: Default> Iterator for SliceVecDrain<'p, 's, T> {
-  type Item = T;
-  #[inline]
-  fn next(&mut self) -> Option<Self::Item> {
-    if self.target_index != self.target_end {
-      let out = core::mem::take(&mut self.parent[self.target_index]);
-      self.target_index += 1;
-      Some(out)
-    } else {
-      None
-    }
-  }
-}
-impl<'p, 's, T: Default> FusedIterator for SliceVecDrain<'p, 's, T> {}
-impl<'p, 's, T: Default> Drop for SliceVecDrain<'p, 's, T> {
-  #[inline]
-  fn drop(&mut self) {
-    // Changed because it was moving `self`, it's also more clear and the std
-    // does the same
-    self.for_each(drop);
-    // Implementation very similar to [`SliceVec::remove`](SliceVec::remove)
-    let count = self.target_end - self.target_start;
-    let targets: &mut [T] = &mut self.parent.deref_mut()[self.target_start..];
-    targets.rotate_left(count);
-    self.parent.len -= count;
-  }
-}
-
-impl<'s, T> AsMut<[T]> for SliceVec<'s, T> {
-  #[inline(always)]
-  #[must_use]
-  fn as_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-}
-
-impl<'s, T> AsRef<[T]> for SliceVec<'s, T> {
-  #[inline(always)]
-  #[must_use]
-  fn as_ref(&self) -> &[T] {
-    &*self
-  }
-}
-
-impl<'s, T> Borrow<[T]> for SliceVec<'s, T> {
-  #[inline(always)]
-  #[must_use]
-  fn borrow(&self) -> &[T] {
-    &*self
-  }
-}
-
-impl<'s, T> BorrowMut<[T]> for SliceVec<'s, T> {
-  #[inline(always)]
-  #[must_use]
-  fn borrow_mut(&mut self) -> &mut [T] {
-    &mut *self
-  }
-}
-
-impl<'s, T> Extend<T> for SliceVec<'s, T> {
-  #[inline]
-  fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-    for t in iter {
-      self.push(t)
-    }
-  }
-}
-
-impl<'s, T> IntoIterator for SliceVec<'s, T> {
-  type Item = &'s mut T;
-  type IntoIter = core::slice::IterMut<'s, T>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    self.data.iter_mut()
-  }
-}
-
-impl<'s, T> PartialEq for SliceVec<'s, T>
-where
-  T: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &Self) -> bool {
-    self.as_slice().eq(other.as_slice())
-  }
-}
-impl<'s, T> Eq for SliceVec<'s, T> where T: Eq {}
-
-impl<'s, T> PartialOrd for SliceVec<'s, T>
-where
-  T: PartialOrd,
-{
-  #[inline]
-  #[must_use]
-  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-    self.as_slice().partial_cmp(other.as_slice())
-  }
-}
-impl<'s, T> Ord for SliceVec<'s, T>
-where
-  T: Ord,
-{
-  #[inline]
-  #[must_use]
-  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
-    self.as_slice().cmp(other.as_slice())
-  }
-}
-
-impl<'s, T> PartialEq<&[T]> for SliceVec<'s, T>
-where
-  T: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &&[T]) -> bool {
-    self.as_slice().eq(*other)
-  }
-}
-
-impl<'s, T> Hash for SliceVec<'s, T>
-where
-  T: Hash,
-{
-  #[inline]
-  fn hash<H: Hasher>(&self, state: &mut H) {
-    self.as_slice().hash(state)
-  }
-}
-
-#[cfg(feature = "experimental_write_impl")]
-impl<'s> core::fmt::Write for SliceVec<'s, u8> {
-  fn write_str(&mut self, s: &str) -> core::fmt::Result {
-    let my_len = self.len();
-    let str_len = s.as_bytes().len();
-    if my_len + str_len <= self.capacity() {
-      let remainder = &mut self.data[my_len..];
-      let target = &mut remainder[..str_len];
-      target.copy_from_slice(s.as_bytes());
-      Ok(())
-    } else {
-      Err(core::fmt::Error)
-    }
-  }
-}
-
-// // // // // // // //
-// Formatting impls
-// // // // // // // //
-
-impl<'s, T> Binary for SliceVec<'s, T>
-where
-  T: Binary,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Binary::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> Debug for SliceVec<'s, T>
-where
-  T: Debug,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() && !self.is_empty() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Debug::fmt(elem, f)?;
-    }
-    if f.alternate() && !self.is_empty() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> Display for SliceVec<'s, T>
-where
-  T: Display,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Display::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> LowerExp for SliceVec<'s, T>
-where
-  T: LowerExp,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      LowerExp::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> LowerHex for SliceVec<'s, T>
-where
-  T: LowerHex,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      LowerHex::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> Octal for SliceVec<'s, T>
-where
-  T: Octal,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Octal::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> Pointer for SliceVec<'s, T>
-where
-  T: Pointer,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Pointer::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> UpperExp for SliceVec<'s, T>
-where
-  T: UpperExp,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      UpperExp::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<'s, T> UpperHex for SliceVec<'s, T>
-where
-  T: UpperHex,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      UpperHex::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
diff --git a/third_party/rust/tinyvec/src/tinyvec.rs b/third_party/rust/tinyvec/src/tinyvec.rs
@@ -1,1910 +0,0 @@
-use super::*;
-
-use alloc::vec::{self, Vec};
-use core::convert::TryFrom;
-use tinyvec_macros::impl_mirrored;
-
-#[cfg(feature = "rustc_1_57")]
-use alloc::collections::TryReserveError;
-
-#[cfg(feature = "serde")]
-use core::marker::PhantomData;
-#[cfg(feature = "serde")]
-use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
-#[cfg(feature = "serde")]
-use serde::ser::{Serialize, SerializeSeq, Serializer};
-
-/// Helper to make a `TinyVec`.
-///
-/// You specify the backing array type, and optionally give all the elements you
-/// want to initially place into the array.
-///
-/// ```rust
-/// use tinyvec::*;
-///
-/// // The backing array type can be specified in the macro call
-/// let empty_tv = tiny_vec!([u8; 16]);
-/// let some_ints = tiny_vec!([i32; 4] => 1, 2, 3);
-/// let many_ints = tiny_vec!([i32; 4] => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-///
-/// // Or left to inference
-/// let empty_tv: TinyVec<[u8; 16]> = tiny_vec!();
-/// let some_ints: TinyVec<[i32; 4]> = tiny_vec!(1, 2, 3);
-/// let many_ints: TinyVec<[i32; 4]> = tiny_vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-/// ```
-#[macro_export]
-#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-macro_rules! tiny_vec {
-  ($array_type:ty => $($elem:expr),* $(,)?) => {
-    {
-      // https://github.com/rust-lang/lang-team/issues/28
-      const INVOKED_ELEM_COUNT: usize = 0 $( + { let _ = stringify!($elem); 1 })*;
-      // If we have more `$elem` than the `CAPACITY` we will simply go directly
-      // to constructing on the heap.
-      match $crate::TinyVec::constructor_for_capacity(INVOKED_ELEM_COUNT) {
-        $crate::TinyVecConstructor::Inline(f) => {
-          f($crate::array_vec!($array_type => $($elem),*))
-        }
-        $crate::TinyVecConstructor::Heap(f) => {
-          f(vec!($($elem),*))
-        }
-      }
-    }
-  };
-  ($array_type:ty) => {
-    $crate::TinyVec::<$array_type>::default()
-  };
-  ($($elem:expr),*) => {
-    $crate::tiny_vec!(_ => $($elem),*)
-  };
-  ($elem:expr; $n:expr) => {
-    $crate::TinyVec::from([$elem; $n])
-  };
-  () => {
-    $crate::tiny_vec!(_)
-  };
-}
-
-#[doc(hidden)] // Internal implementation details of `tiny_vec!`
-pub enum TinyVecConstructor<A: Array> {
-  Inline(fn(ArrayVec<A>) -> TinyVec<A>),
-  Heap(fn(Vec<A::Item>) -> TinyVec<A>),
-}
-
-/// A vector that starts inline, but can automatically move to the heap.
-///
-/// * Requires the `alloc` feature
-///
-/// A `TinyVec` is either an Inline([`ArrayVec`](crate::ArrayVec::<A>)) or
-/// Heap([`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)). The
-/// interface for the type as a whole is a bunch of methods that just match on
-/// the enum variant and then call the same method on the inner vec.
-///
-/// ## Construction
-///
-/// Because it's an enum, you can construct a `TinyVec` simply by making an
-/// `ArrayVec` or `Vec` and then putting it into the enum.
-///
-/// There is also a macro
-///
-/// ```rust
-/// # use tinyvec::*;
-/// let empty_tv = tiny_vec!([u8; 16]);
-/// let some_ints = tiny_vec!([i32; 4] => 1, 2, 3);
-/// ```
-#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub enum TinyVec<A: Array> {
-  #[allow(missing_docs)]
-  Inline(ArrayVec<A>),
-  #[allow(missing_docs)]
-  Heap(Vec<A::Item>),
-}
-
-impl<A> Clone for TinyVec<A>
-where
-  A: Array + Clone,
-  A::Item: Clone,
-{
-  #[inline]
-  fn clone(&self) -> Self {
-    match self {
-      TinyVec::Heap(v) => TinyVec::Heap(v.clone()),
-      TinyVec::Inline(v) => TinyVec::Inline(v.clone()),
-    }
-  }
-
-  #[inline]
-  fn clone_from(&mut self, o: &Self) {
-    if o.len() > self.len() {
-      self.reserve(o.len() - self.len());
-    } else {
-      self.truncate(o.len());
-    }
-    let (start, end) = o.split_at(self.len());
-    for (dst, src) in self.iter_mut().zip(start) {
-      dst.clone_from(src);
-    }
-    self.extend_from_slice(end);
-  }
-}
-
-impl<A: Array> Default for TinyVec<A> {
-  #[inline]
-  #[must_use]
-  fn default() -> Self {
-    TinyVec::Inline(ArrayVec::default())
-  }
-}
-
-impl<A: Array> Deref for TinyVec<A> {
-  type Target = [A::Item];
-
-  impl_mirrored! {
-    type Mirror = TinyVec;
-    #[inline(always)]
-    #[must_use]
-    fn deref(self: &Self) -> &Self::Target;
-  }
-}
-
-impl<A: Array> DerefMut for TinyVec<A> {
-  impl_mirrored! {
-    type Mirror = TinyVec;
-    #[inline(always)]
-    #[must_use]
-    fn deref_mut(self: &mut Self) -> &mut Self::Target;
-  }
-}
-
-impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for TinyVec<A> {
-  type Output = <I as SliceIndex<[A::Item]>>::Output;
-  #[inline(always)]
-  #[must_use]
-  fn index(&self, index: I) -> &Self::Output {
-    &self.deref()[index]
-  }
-}
-
-impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for TinyVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn index_mut(&mut self, index: I) -> &mut Self::Output {
-    &mut self.deref_mut()[index]
-  }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "std")))]
-impl<A: Array<Item = u8>> std::io::Write for TinyVec<A> {
-  #[inline(always)]
-  fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-    self.extend_from_slice(buf);
-    Ok(buf.len())
-  }
-
-  #[inline(always)]
-  fn flush(&mut self) -> std::io::Result<()> {
-    Ok(())
-  }
-}
-
-#[cfg(feature = "serde")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "serde")))]
-impl<A: Array> Serialize for TinyVec<A>
-where
-  A::Item: Serialize,
-{
-  #[must_use]
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: Serializer,
-  {
-    let mut seq = serializer.serialize_seq(Some(self.len()))?;
-    for element in self.iter() {
-      seq.serialize_element(element)?;
-    }
-    seq.end()
-  }
-}
-
-#[cfg(feature = "serde")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "serde")))]
-impl<'de, A: Array> Deserialize<'de> for TinyVec<A>
-where
-  A::Item: Deserialize<'de>,
-{
-  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-  where
-    D: Deserializer<'de>,
-  {
-    deserializer.deserialize_seq(TinyVecVisitor(PhantomData))
-  }
-}
-
-#[cfg(feature = "borsh")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "borsh")))]
-impl<A: Array> borsh::BorshSerialize for TinyVec<A>
-where
-  <A as Array>::Item: borsh::BorshSerialize,
-{
-  fn serialize<W: borsh::io::Write>(
-    &self, writer: &mut W,
-  ) -> borsh::io::Result<()> {
-    <usize as borsh::BorshSerialize>::serialize(&self.len(), writer)?;
-    for elem in self.iter() {
-      <<A as Array>::Item as borsh::BorshSerialize>::serialize(elem, writer)?;
-    }
-    Ok(())
-  }
-}
-
-#[cfg(feature = "borsh")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "borsh")))]
-impl<A: Array> borsh::BorshDeserialize for TinyVec<A>
-where
-  <A as Array>::Item: borsh::BorshDeserialize,
-{
-  fn deserialize_reader<R: borsh::io::Read>(
-    reader: &mut R,
-  ) -> borsh::io::Result<Self> {
-    let len = <usize as borsh::BorshDeserialize>::deserialize_reader(reader)?;
-    let mut new_tinyvec = Self::with_capacity(len);
-
-    for _ in 0..len {
-      new_tinyvec.push(
-        <<A as Array>::Item as borsh::BorshDeserialize>::deserialize_reader(
-          reader,
-        )?,
-      )
-    }
-
-    Ok(new_tinyvec)
-  }
-}
-
-#[cfg(feature = "arbitrary")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "arbitrary")))]
-impl<'a, A> arbitrary::Arbitrary<'a> for TinyVec<A>
-where
-  A: Array,
-  A::Item: arbitrary::Arbitrary<'a>,
-{
-  fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-    let v = Vec::arbitrary(u)?;
-    let mut tv = TinyVec::Heap(v);
-    tv.shrink_to_fit();
-    Ok(tv)
-  }
-}
-
-impl<A: Array> TinyVec<A> {
-  /// Returns whether elements are on heap
-  #[inline(always)]
-  #[must_use]
-  pub fn is_heap(&self) -> bool {
-    match self {
-      TinyVec::Heap(_) => true,
-      TinyVec::Inline(_) => false,
-    }
-  }
-  /// Returns whether elements are on stack
-  #[inline(always)]
-  #[must_use]
-  pub fn is_inline(&self) -> bool {
-    !self.is_heap()
-  }
-
-  /// Shrinks the capacity of the vector as much as possible.\
-  /// It is inlined if length is less than `A::CAPACITY`.
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 2] => 1, 2, 3);
-  /// assert!(tv.is_heap());
-  /// let _ = tv.pop();
-  /// assert!(tv.is_heap());
-  /// tv.shrink_to_fit();
-  /// assert!(tv.is_inline());
-  /// ```
-  #[inline]
-  pub fn shrink_to_fit(&mut self) {
-    let vec = match self {
-      TinyVec::Inline(_) => return,
-      TinyVec::Heap(h) => h,
-    };
-
-    if vec.len() > A::CAPACITY {
-      return vec.shrink_to_fit();
-    }
-
-    let moved_vec = core::mem::take(vec);
-
-    let mut av = ArrayVec::default();
-    let mut rest = av.fill(moved_vec);
-    debug_assert!(rest.next().is_none());
-    *self = TinyVec::Inline(av);
-  }
-
-  /// Moves the content of the TinyVec to the heap, if it's inline.
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// assert!(tv.is_inline());
-  /// tv.move_to_the_heap();
-  /// assert!(tv.is_heap());
-  /// ```
-  #[allow(clippy::missing_inline_in_public_items)]
-  pub fn move_to_the_heap(&mut self) {
-    let arr = match self {
-      TinyVec::Heap(_) => return,
-      TinyVec::Inline(a) => a,
-    };
-
-    let v = arr.drain_to_vec();
-    *self = TinyVec::Heap(v);
-  }
-
-  /// Tries to move the content of the TinyVec to the heap, if it's inline.
-  ///
-  /// # Errors
-  ///
-  /// If the allocator reports a failure, then an error is returned and the
-  /// content is kept on the stack.
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// assert!(tv.is_inline());
-  /// assert_eq!(Ok(()), tv.try_move_to_the_heap());
-  /// assert!(tv.is_heap());
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_57")]
-  pub fn try_move_to_the_heap(&mut self) -> Result<(), TryReserveError> {
-    let arr = match self {
-      TinyVec::Heap(_) => return Ok(()),
-      TinyVec::Inline(a) => a,
-    };
-
-    let v = arr.try_drain_to_vec()?;
-    *self = TinyVec::Heap(v);
-    return Ok(());
-  }
-
-  /// If TinyVec is inline, moves the content of it to the heap.
-  /// Also reserves additional space.
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// assert!(tv.is_inline());
-  /// tv.move_to_the_heap_and_reserve(32);
-  /// assert!(tv.is_heap());
-  /// assert!(tv.capacity() >= 35);
-  /// ```
-  #[inline]
-  pub fn move_to_the_heap_and_reserve(&mut self, n: usize) {
-    let arr = match self {
-      TinyVec::Heap(h) => return h.reserve(n),
-      TinyVec::Inline(a) => a,
-    };
-
-    let v = arr.drain_to_vec_and_reserve(n);
-    *self = TinyVec::Heap(v);
-  }
-
-  /// If TinyVec is inline, try to move the content of it to the heap.
-  /// Also reserves additional space.
-  ///
-  /// # Errors
-  ///
-  /// If the allocator reports a failure, then an error is returned.
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// assert!(tv.is_inline());
-  /// assert_eq!(Ok(()), tv.try_move_to_the_heap_and_reserve(32));
-  /// assert!(tv.is_heap());
-  /// assert!(tv.capacity() >= 35);
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_57")]
-  pub fn try_move_to_the_heap_and_reserve(
-    &mut self, n: usize,
-  ) -> Result<(), TryReserveError> {
-    let arr = match self {
-      TinyVec::Heap(h) => return h.try_reserve(n),
-      TinyVec::Inline(a) => a,
-    };
-
-    let v = arr.try_drain_to_vec_and_reserve(n)?;
-    *self = TinyVec::Heap(v);
-    return Ok(());
-  }
-
-  /// Reserves additional space.
-  /// Moves to the heap if array can't hold `n` more items
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
-  /// assert!(tv.is_inline());
-  /// tv.reserve(1);
-  /// assert!(tv.is_heap());
-  /// assert!(tv.capacity() >= 5);
-  /// ```
-  #[inline]
-  pub fn reserve(&mut self, n: usize) {
-    let arr = match self {
-      TinyVec::Heap(h) => return h.reserve(n),
-      TinyVec::Inline(a) => a,
-    };
-
-    if n > arr.capacity() - arr.len() {
-      let v = arr.drain_to_vec_and_reserve(n);
-      *self = TinyVec::Heap(v);
-    }
-
-    /* In this place array has enough place, so no work is needed more */
-    return;
-  }
-
-  /// Tries to reserve additional space.
-  /// Moves to the heap if array can't hold `n` more items.
-  ///
-  /// # Errors
-  ///
-  /// If the allocator reports a failure, then an error is returned.
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
-  /// assert!(tv.is_inline());
-  /// assert_eq!(Ok(()), tv.try_reserve(1));
-  /// assert!(tv.is_heap());
-  /// assert!(tv.capacity() >= 5);
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_57")]
-  pub fn try_reserve(&mut self, n: usize) -> Result<(), TryReserveError> {
-    let arr = match self {
-      TinyVec::Heap(h) => return h.try_reserve(n),
-      TinyVec::Inline(a) => a,
-    };
-
-    if n > arr.capacity() - arr.len() {
-      let v = arr.try_drain_to_vec_and_reserve(n)?;
-      *self = TinyVec::Heap(v);
-    }
-
-    /* In this place array has enough place, so no work is needed more */
-    return Ok(());
-  }
-
-  /// Reserves additional space.
-  /// Moves to the heap if array can't hold `n` more items
-  ///
-  /// From [Vec::reserve_exact](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.reserve_exact)
-  /// ```text
-  /// Note that the allocator may give the collection more space than it requests.
-  /// Therefore, capacity can not be relied upon to be precisely minimal.
-  /// Prefer `reserve` if future insertions are expected.
-  /// ```
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
-  /// assert!(tv.is_inline());
-  /// tv.reserve_exact(1);
-  /// assert!(tv.is_heap());
-  /// assert!(tv.capacity() >= 5);
-  /// ```
-  #[inline]
-  pub fn reserve_exact(&mut self, n: usize) {
-    let arr = match self {
-      TinyVec::Heap(h) => return h.reserve_exact(n),
-      TinyVec::Inline(a) => a,
-    };
-
-    if n > arr.capacity() - arr.len() {
-      let v = arr.drain_to_vec_and_reserve(n);
-      *self = TinyVec::Heap(v);
-    }
-
-    /* In this place array has enough place, so no work is needed more */
-    return;
-  }
-
-  /// Tries to reserve additional space.
-  /// Moves to the heap if array can't hold `n` more items
-  ///
-  /// # Errors
-  ///
-  /// If the allocator reports a failure, then an error is returned.
-  ///
-  /// From [Vec::try_reserve_exact](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.try_reserve_exact)
-  /// ```text
-  /// Note that the allocator may give the collection more space than it requests.
-  /// Therefore, capacity can not be relied upon to be precisely minimal.
-  /// Prefer `reserve` if future insertions are expected.
-  /// ```
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
-  /// assert!(tv.is_inline());
-  /// assert_eq!(Ok(()), tv.try_reserve_exact(1));
-  /// assert!(tv.is_heap());
-  /// assert!(tv.capacity() >= 5);
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_57")]
-  pub fn try_reserve_exact(&mut self, n: usize) -> Result<(), TryReserveError> {
-    let arr = match self {
-      TinyVec::Heap(h) => return h.try_reserve_exact(n),
-      TinyVec::Inline(a) => a,
-    };
-
-    if n > arr.capacity() - arr.len() {
-      let v = arr.try_drain_to_vec_and_reserve(n)?;
-      *self = TinyVec::Heap(v);
-    }
-
-    /* In this place array has enough place, so no work is needed more */
-    return Ok(());
-  }
-
-  /// Makes a new TinyVec with _at least_ the given capacity.
-  ///
-  /// If the requested capacity is less than or equal to the array capacity you
-  /// get an inline vec. If it's greater than you get a heap vec.
-  /// ```
-  /// # use tinyvec::*;
-  /// let t = TinyVec::<[u8; 10]>::with_capacity(5);
-  /// assert!(t.is_inline());
-  /// assert!(t.capacity() >= 5);
-  ///
-  /// let t = TinyVec::<[u8; 10]>::with_capacity(20);
-  /// assert!(t.is_heap());
-  /// assert!(t.capacity() >= 20);
-  /// ```
-  #[inline]
-  #[must_use]
-  pub fn with_capacity(cap: usize) -> Self {
-    if cap <= A::CAPACITY {
-      TinyVec::Inline(ArrayVec::default())
-    } else {
-      TinyVec::Heap(Vec::with_capacity(cap))
-    }
-  }
-
-  /// Converts a `TinyVec<[T; N]>` into a `Box<[T]>`.
-  ///
-  /// - For `TinyVec::Heap(Vec<T>)`, it takes the `Vec<T>` and converts it into
-  ///   a `Box<[T]>` without heap reallocation.
-  /// - For `TinyVec::Inline(inner_data)`, it first converts the `inner_data` to
-  ///   `Vec<T>`, then into a `Box<[T]>`. Requiring only a single heap
-  ///   allocation.
-  ///
-  /// ## Example
-  ///
-  /// ```
-  /// use core::mem::size_of_val as mem_size_of;
-  /// use tinyvec::TinyVec;
-  ///
-  /// // Initialize TinyVec with 256 elements (exceeding inline capacity)
-  /// let v: TinyVec<[_; 128]> = (0u8..=255).collect();
-  ///
-  /// assert!(v.is_heap());
-  /// assert_eq!(mem_size_of(&v), 136); // mem size of TinyVec<[u8; N]>: N+8
-  /// assert_eq!(v.len(), 256);
-  ///
-  /// let boxed = v.into_boxed_slice();
-  /// assert_eq!(mem_size_of(&boxed), 16); // mem size of Box<[u8]>: 16 bytes (fat pointer)
-  /// assert_eq!(boxed.len(), 256);
-  /// ```
-  #[inline]
-  #[must_use]
-  pub fn into_boxed_slice(self) -> alloc::boxed::Box<[A::Item]> {
-    self.into_vec().into_boxed_slice()
-  }
-
-  /// Converts a `TinyVec<[T; N]>` into a `Vec<T>`.
-  ///
-  /// `v.into_vec()` is equivalent to `Into::<Vec<_>>::into(v)`.
-  ///
-  /// - For `TinyVec::Inline(_)`, `.into_vec()` **does not** offer a performance
-  ///   advantage over `.to_vec()`.
-  /// - For `TinyVec::Heap(vec_data)`, `.into_vec()` will take `vec_data`
-  ///   without heap reallocation.
-  ///
-  /// ## Example
-  ///
-  /// ```
-  /// use tinyvec::TinyVec;
-  ///
-  /// let v = TinyVec::from([0u8; 8]);
-  /// let v2 = v.clone();
-  ///
-  /// let vec = v.into_vec();
-  /// let vec2: Vec<_> = v2.into();
-  ///
-  /// assert_eq!(vec, vec2);
-  /// ```
-  #[inline]
-  #[must_use]
-  pub fn into_vec(self) -> Vec<A::Item> {
-    self.into()
-  }
-}
-
-impl<A: Array> TinyVec<A> {
-  /// Move all values from `other` into this vec.
-  #[inline]
-  pub fn append(&mut self, other: &mut Self) {
-    self.reserve(other.len());
-
-    /* Doing append should be faster, because it is effectively a memcpy */
-    match (self, other) {
-      (TinyVec::Heap(sh), TinyVec::Heap(oh)) => sh.append(oh),
-      (TinyVec::Inline(a), TinyVec::Heap(h)) => a.extend(h.drain(..)),
-      (ref mut this, TinyVec::Inline(arr)) => this.extend(arr.drain(..)),
-    }
-  }
-
-  impl_mirrored! {
-    type Mirror = TinyVec;
-
-    /// Remove an element, swapping the end of the vec into its place.
-    ///
-    /// ## Panics
-    /// * If the index is out of bounds.
-    ///
-    /// ## Example
-    /// ```rust
-    /// use tinyvec::*;
-    /// let mut tv = tiny_vec!([&str; 4] => "foo", "bar", "quack", "zap");
-    ///
-    /// assert_eq!(tv.swap_remove(1), "bar");
-    /// assert_eq!(tv.as_slice(), &["foo", "zap", "quack"][..]);
-    ///
-    /// assert_eq!(tv.swap_remove(0), "foo");
-    /// assert_eq!(tv.as_slice(), &["quack", "zap"][..]);
-    /// ```
-    #[inline]
-    pub fn swap_remove(self: &mut Self, index: usize) -> A::Item;
-
-    /// Remove and return the last element of the vec, if there is one.
-    ///
-    /// ## Failure
-    /// * If the vec is empty you get `None`.
-    #[inline]
-    pub fn pop(self: &mut Self) -> Option<A::Item>;
-
-    /// Removes the item at `index`, shifting all others down by one index.
-    ///
-    /// Returns the removed element.
-    ///
-    /// ## Panics
-    ///
-    /// If the index is out of bounds.
-    ///
-    /// ## Example
-    ///
-    /// ```rust
-    /// use tinyvec::*;
-    /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-    /// assert_eq!(tv.remove(1), 2);
-    /// assert_eq!(tv.as_slice(), &[1, 3][..]);
-    /// ```
-    #[inline]
-    pub fn remove(self: &mut Self, index: usize) -> A::Item;
-
-    /// The length of the vec (in elements).
-    #[inline(always)]
-    #[must_use]
-    pub fn len(self: &Self) -> usize;
-
-    /// The capacity of the `TinyVec`.
-    ///
-    /// When not heap allocated this is fixed based on the array type.
-    /// Otherwise its the result of the underlying Vec::capacity.
-    #[inline(always)]
-    #[must_use]
-    pub fn capacity(self: &Self) -> usize;
-
-    /// Reduces the vec's length to the given value.
-    ///
-    /// If the vec is already shorter than the input, nothing happens.
-    #[inline]
-    pub fn truncate(self: &mut Self, new_len: usize);
-
-    /// A mutable pointer to the backing array.
-    ///
-    /// ## Safety
-    ///
-    /// This pointer has provenance over the _entire_ backing array/buffer.
-    #[inline(always)]
-    #[must_use]
-    pub fn as_mut_ptr(self: &mut Self) -> *mut A::Item;
-
-    /// A const pointer to the backing array.
-    ///
-    /// ## Safety
-    ///
-    /// This pointer has provenance over the _entire_ backing array/buffer.
-    #[inline(always)]
-    #[must_use]
-    pub fn as_ptr(self: &Self) -> *const A::Item;
-  }
-
-  /// Walk the vec and keep only the elements that pass the predicate given.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  ///
-  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);
-  /// tv.retain(|&x| x % 2 == 0);
-  /// assert_eq!(tv.as_slice(), &[2, 4][..]);
-  /// ```
-  #[inline]
-  pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, acceptable: F) {
-    match self {
-      TinyVec::Inline(i) => i.retain(acceptable),
-      TinyVec::Heap(h) => h.retain(acceptable),
-    }
-  }
-
-  /// Walk the vec and keep only the elements that pass the predicate given,
-  /// having the opportunity to modify the elements at the same time.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  ///
-  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);
-  /// tv.retain_mut(|x| if *x % 2 == 0 { *x *= 2; true } else { false });
-  /// assert_eq!(tv.as_slice(), &[4, 8][..]);
-  /// ```
-  #[inline]
-  #[cfg(feature = "rustc_1_61")]
-  pub fn retain_mut<F: FnMut(&mut A::Item) -> bool>(&mut self, acceptable: F) {
-    match self {
-      TinyVec::Inline(i) => i.retain_mut(acceptable),
-      TinyVec::Heap(h) => h.retain_mut(acceptable),
-    }
-  }
-
-  /// Helper for getting the mut slice.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_mut_slice(&mut self) -> &mut [A::Item] {
-    self.deref_mut()
-  }
-
-  /// Helper for getting the shared slice.
-  #[inline(always)]
-  #[must_use]
-  pub fn as_slice(&self) -> &[A::Item] {
-    self.deref()
-  }
-
-  /// Removes all elements from the vec.
-  #[inline(always)]
-  pub fn clear(&mut self) {
-    self.truncate(0)
-  }
-
-  /// De-duplicates the vec.
-  #[cfg(feature = "nightly_slice_partition_dedup")]
-  #[inline(always)]
-  pub fn dedup(&mut self)
-  where
-    A::Item: PartialEq,
-  {
-    self.dedup_by(|a, b| a == b)
-  }
-
-  /// De-duplicates the vec according to the predicate given.
-  #[cfg(feature = "nightly_slice_partition_dedup")]
-  #[inline(always)]
-  pub fn dedup_by<F>(&mut self, same_bucket: F)
-  where
-    F: FnMut(&mut A::Item, &mut A::Item) -> bool,
-  {
-    let len = {
-      let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket);
-      dedup.len()
-    };
-    self.truncate(len);
-  }
-
-  /// De-duplicates the vec according to the key selector given.
-  #[cfg(feature = "nightly_slice_partition_dedup")]
-  #[inline(always)]
-  pub fn dedup_by_key<F, K>(&mut self, mut key: F)
-  where
-    F: FnMut(&mut A::Item) -> K,
-    K: PartialEq,
-  {
-    self.dedup_by(|a, b| key(a) == key(b))
-  }
-
-  /// Creates a draining iterator that removes the specified range in the vector
-  /// and yields the removed items.
-  ///
-  /// **Note: This method has significant performance issues compared to
-  /// matching on the TinyVec and then calling drain on the Inline or Heap value
-  /// inside. The draining iterator has to branch on every single access. It is
-  /// provided for simplicity and compatibility only.**
-  ///
-  /// ## Panics
-  /// * If the start is greater than the end
-  /// * If the end is past the edge of the vec.
-  ///
-  /// ## Example
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// let tv2: TinyVec<[i32; 4]> = tv.drain(1..).collect();
-  /// assert_eq!(tv.as_slice(), &[1][..]);
-  /// assert_eq!(tv2.as_slice(), &[2, 3][..]);
-  ///
-  /// tv.drain(..);
-  /// assert_eq!(tv.as_slice(), &[]);
-  /// ```
-  #[inline]
-  pub fn drain<R: RangeBounds<usize>>(
-    &mut self, range: R,
-  ) -> TinyVecDrain<'_, A> {
-    match self {
-      TinyVec::Inline(i) => TinyVecDrain::Inline(i.drain(range)),
-      TinyVec::Heap(h) => TinyVecDrain::Heap(h.drain(range)),
-    }
-  }
-
-  /// Clone each element of the slice into this vec.
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2);
-  /// tv.extend_from_slice(&[3, 4]);
-  /// assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
-  /// ```
-  #[inline]
-  pub fn extend_from_slice(&mut self, sli: &[A::Item])
-  where
-    A::Item: Clone,
-  {
-    self.reserve(sli.len());
-    match self {
-      TinyVec::Inline(a) => a.extend_from_slice(sli),
-      TinyVec::Heap(h) => h.extend_from_slice(sli),
-    }
-  }
-
-  /// Wraps up an array and uses the given length as the initial length.
-  ///
-  /// Note that the `From` impl for arrays assumes the full length is used.
-  ///
-  /// ## Panics
-  ///
-  /// The length must be less than or equal to the capacity of the array.
-  #[inline]
-  #[must_use]
-  #[allow(clippy::match_wild_err_arm)]
-  pub fn from_array_len(data: A, len: usize) -> Self {
-    match Self::try_from_array_len(data, len) {
-      Ok(out) => out,
-      Err(_) => {
-        panic!("TinyVec: length {} exceeds capacity {}!", len, A::CAPACITY)
-      }
-    }
-  }
-
-  /// This is an internal implementation detail of the `tiny_vec!` macro, and
-  /// using it other than from that macro is not supported by this crate's
-  /// SemVer guarantee.
-  #[inline(always)]
-  #[doc(hidden)]
-  pub fn constructor_for_capacity(cap: usize) -> TinyVecConstructor<A> {
-    if cap <= A::CAPACITY {
-      TinyVecConstructor::Inline(TinyVec::Inline)
-    } else {
-      TinyVecConstructor::Heap(TinyVec::Heap)
-    }
-  }
-
-  /// Inserts an item at the position given, moving all following elements +1
-  /// index.
-  ///
-  /// ## Panics
-  /// * If `index` > `len`
-  ///
-  /// ## Example
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3);
-  /// tv.insert(1, 4);
-  /// assert_eq!(tv.as_slice(), &[1, 4, 2, 3]);
-  /// tv.insert(4, 5);
-  /// assert_eq!(tv.as_slice(), &[1, 4, 2, 3, 5]);
-  /// ```
-  #[inline]
-  pub fn insert(&mut self, index: usize, item: A::Item) {
-    assert!(
-      index <= self.len(),
-      "insertion index (is {}) should be <= len (is {})",
-      index,
-      self.len()
-    );
-
-    let arr = match self {
-      TinyVec::Heap(v) => return v.insert(index, item),
-      TinyVec::Inline(a) => a,
-    };
-
-    if let Some(x) = arr.try_insert(index, item) {
-      let mut v = Vec::with_capacity(arr.len() * 2);
-      let mut it = arr.iter_mut().map(core::mem::take);
-      v.extend(it.by_ref().take(index));
-      v.push(x);
-      v.extend(it);
-      *self = TinyVec::Heap(v);
-    }
-  }
-
-  /// If the vec is empty.
-  #[inline(always)]
-  #[must_use]
-  pub fn is_empty(&self) -> bool {
-    self.len() == 0
-  }
-
-  /// Makes a new, empty vec.
-  #[inline(always)]
-  #[must_use]
-  pub fn new() -> Self {
-    Self::default()
-  }
-
-  /// Place an element onto the end of the vec.
-  #[inline]
-  pub fn push(&mut self, val: A::Item) {
-    // The code path for moving the inline contents to the heap produces a lot
-    // of instructions, but we have a strong guarantee that this is a cold
-    // path. LLVM doesn't know this, inlines it, and this tends to cause a
-    // cascade of other bad inlining decisions because the body of push looks
-    // huge even though nearly every call executes the same few instructions.
-    //
-    // Moving the logic out of line with #[cold] causes the hot code to  be
-    // inlined together, and we take the extra cost of a function call only
-    // in rare cases.
-    #[cold]
-    fn drain_to_heap_and_push<A: Array>(
-      arr: &mut ArrayVec<A>, val: A::Item,
-    ) -> TinyVec<A> {
-      /* Make the Vec twice the size to amortize the cost of draining */
-      let mut v = arr.drain_to_vec_and_reserve(arr.len());
-      v.push(val);
-      TinyVec::Heap(v)
-    }
-
-    match self {
-      TinyVec::Heap(v) => v.push(val),
-      TinyVec::Inline(arr) => {
-        if let Some(x) = arr.try_push(val) {
-          *self = drain_to_heap_and_push(arr, x);
-        }
-      }
-    }
-  }
-
-  /// Resize the vec to the new length.
-  ///
-  /// If it needs to be longer, it's filled with clones of the provided value.
-  /// If it needs to be shorter, it's truncated.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  ///
-  /// let mut tv = tiny_vec!([&str; 10] => "hello");
-  /// tv.resize(3, "world");
-  /// assert_eq!(tv.as_slice(), &["hello", "world", "world"][..]);
-  ///
-  /// let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);
-  /// tv.resize(2, 0);
-  /// assert_eq!(tv.as_slice(), &[1, 2][..]);
-  /// ```
-  #[inline]
-  pub fn resize(&mut self, new_len: usize, new_val: A::Item)
-  where
-    A::Item: Clone,
-  {
-    self.resize_with(new_len, || new_val.clone());
-  }
-
-  /// Resize the vec to the new length.
-  ///
-  /// If it needs to be longer, it's filled with repeated calls to the provided
-  /// function. If it needs to be shorter, it's truncated.
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  ///
-  /// let mut tv = tiny_vec!([i32; 3] => 1, 2, 3);
-  /// tv.resize_with(5, Default::default);
-  /// assert_eq!(tv.as_slice(), &[1, 2, 3, 0, 0][..]);
-  ///
-  /// let mut tv = tiny_vec!([i32; 2]);
-  /// let mut p = 1;
-  /// tv.resize_with(4, || {
-  ///   p *= 2;
-  ///   p
-  /// });
-  /// assert_eq!(tv.as_slice(), &[2, 4, 8, 16][..]);
-  /// ```
-  #[inline]
-  pub fn resize_with<F: FnMut() -> A::Item>(&mut self, new_len: usize, f: F) {
-    match new_len.checked_sub(self.len()) {
-      None => return self.truncate(new_len),
-      Some(n) => self.reserve(n),
-    }
-
-    match self {
-      TinyVec::Inline(a) => a.resize_with(new_len, f),
-      TinyVec::Heap(v) => v.resize_with(new_len, f),
-    }
-  }
-
-  /// Splits the collection at the point given.
-  ///
-  /// * `[0, at)` stays in this vec
-  /// * `[at, len)` ends up in the new vec.
-  ///
-  /// ## Panics
-  /// * if at > len
-  ///
-  /// ## Example
-  ///
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// let tv2 = tv.split_off(1);
-  /// assert_eq!(tv.as_slice(), &[1][..]);
-  /// assert_eq!(tv2.as_slice(), &[2, 3][..]);
-  /// ```
-  #[inline]
-  pub fn split_off(&mut self, at: usize) -> Self {
-    match self {
-      TinyVec::Inline(a) => TinyVec::Inline(a.split_off(at)),
-      TinyVec::Heap(v) => TinyVec::Heap(v.split_off(at)),
-    }
-  }
-
-  /// Creates a splicing iterator that removes the specified range in the
-  /// vector, yields the removed items, and replaces them with elements from
-  /// the provided iterator.
-  ///
-  /// `splice` fuses the provided iterator, so elements after the first `None`
-  /// are ignored.
-  ///
-  /// ## Panics
-  /// * If the start is greater than the end.
-  /// * If the end is past the edge of the vec.
-  /// * If the provided iterator panics.
-  ///
-  /// ## Example
-  /// ```rust
-  /// use tinyvec::*;
-  /// let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  /// let tv2: TinyVec<[i32; 4]> = tv.splice(1.., 4..=6).collect();
-  /// assert_eq!(tv.as_slice(), &[1, 4, 5, 6][..]);
-  /// assert_eq!(tv2.as_slice(), &[2, 3][..]);
-  ///
-  /// tv.splice(.., None);
-  /// assert_eq!(tv.as_slice(), &[]);
-  /// ```
-  #[inline]
-  pub fn splice<R, I>(
-    &mut self, range: R, replacement: I,
-  ) -> TinyVecSplice<'_, A, core::iter::Fuse<I::IntoIter>>
-  where
-    R: RangeBounds<usize>,
-    I: IntoIterator<Item = A::Item>,
-  {
-    use core::ops::Bound;
-    let start = match range.start_bound() {
-      Bound::Included(x) => *x,
-      Bound::Excluded(x) => x.saturating_add(1),
-      Bound::Unbounded => 0,
-    };
-    let end = match range.end_bound() {
-      Bound::Included(x) => x.saturating_add(1),
-      Bound::Excluded(x) => *x,
-      Bound::Unbounded => self.len(),
-    };
-    assert!(
-      start <= end,
-      "TinyVec::splice> Illegal range, {} to {}",
-      start,
-      end
-    );
-    assert!(
-      end <= self.len(),
-      "TinyVec::splice> Range ends at {} but length is only {}!",
-      end,
-      self.len()
-    );
-
-    TinyVecSplice {
-      removal_start: start,
-      removal_end: end,
-      parent: self,
-      replacement: replacement.into_iter().fuse(),
-    }
-  }
-
-  /// Wraps an array, using the given length as the starting length.
-  ///
-  /// If you want to use the whole length of the array, you can just use the
-  /// `From` impl.
-  ///
-  /// ## Failure
-  ///
-  /// If the given length is greater than the capacity of the array this will
-  /// error, and you'll get the array back in the `Err`.
-  #[inline]
-  pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A> {
-    let arr = ArrayVec::try_from_array_len(data, len)?;
-    Ok(TinyVec::Inline(arr))
-  }
-}
-
-/// Draining iterator for `TinyVecDrain`
-///
-/// See [`TinyVecDrain::drain`](TinyVecDrain::<A>::drain)
-#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub enum TinyVecDrain<'p, A: Array> {
-  #[allow(missing_docs)]
-  Inline(ArrayVecDrain<'p, A::Item>),
-  #[allow(missing_docs)]
-  Heap(vec::Drain<'p, A::Item>),
-}
-
-impl<'p, A: Array> Iterator for TinyVecDrain<'p, A> {
-  type Item = A::Item;
-
-  impl_mirrored! {
-    type Mirror = TinyVecDrain;
-
-    #[inline]
-    fn next(self: &mut Self) -> Option<Self::Item>;
-    #[inline]
-    fn nth(self: &mut Self, n: usize) -> Option<Self::Item>;
-    #[inline]
-    fn size_hint(self: &Self) -> (usize, Option<usize>);
-    #[inline]
-    fn last(self: Self) -> Option<Self::Item>;
-    #[inline]
-    fn count(self: Self) -> usize;
-  }
-
-  #[inline]
-  fn for_each<F: FnMut(Self::Item)>(self, f: F) {
-    match self {
-      TinyVecDrain::Inline(i) => i.for_each(f),
-      TinyVecDrain::Heap(h) => h.for_each(f),
-    }
-  }
-}
-
-impl<'p, A: Array> DoubleEndedIterator for TinyVecDrain<'p, A> {
-  impl_mirrored! {
-    type Mirror = TinyVecDrain;
-
-    #[inline]
-    fn next_back(self: &mut Self) -> Option<Self::Item>;
-
-    #[inline]
-    fn nth_back(self: &mut Self, n: usize) -> Option<Self::Item>;
-  }
-}
-
-/// Splicing iterator for `TinyVec`
-/// See [`TinyVec::splice`](TinyVec::<A>::splice)
-#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub struct TinyVecSplice<'p, A: Array, I: Iterator<Item = A::Item>> {
-  parent: &'p mut TinyVec<A>,
-  removal_start: usize,
-  removal_end: usize,
-  replacement: I,
-}
-
-impl<'p, A, I> Iterator for TinyVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item>,
-{
-  type Item = A::Item;
-
-  #[inline]
-  fn next(&mut self) -> Option<A::Item> {
-    if self.removal_start < self.removal_end {
-      match self.replacement.next() {
-        Some(replacement) => {
-          let removed = core::mem::replace(
-            &mut self.parent[self.removal_start],
-            replacement,
-          );
-          self.removal_start += 1;
-          Some(removed)
-        }
-        None => {
-          let removed = self.parent.remove(self.removal_start);
-          self.removal_end -= 1;
-          Some(removed)
-        }
-      }
-    } else {
-      None
-    }
-  }
-
-  #[inline]
-  fn size_hint(&self) -> (usize, Option<usize>) {
-    let len = self.len();
-    (len, Some(len))
-  }
-}
-
-impl<'p, A, I> ExactSizeIterator for TinyVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item>,
-{
-  #[inline]
-  fn len(&self) -> usize {
-    self.removal_end - self.removal_start
-  }
-}
-
-impl<'p, A, I> FusedIterator for TinyVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item>,
-{
-}
-
-impl<'p, A, I> DoubleEndedIterator for TinyVecSplice<'p, A, I>
-where
-  A: Array,
-  I: Iterator<Item = A::Item> + DoubleEndedIterator,
-{
-  #[inline]
-  fn next_back(&mut self) -> Option<A::Item> {
-    if self.removal_start < self.removal_end {
-      match self.replacement.next_back() {
-        Some(replacement) => {
-          let removed = core::mem::replace(
-            &mut self.parent[self.removal_end - 1],
-            replacement,
-          );
-          self.removal_end -= 1;
-          Some(removed)
-        }
-        None => {
-          let removed = self.parent.remove(self.removal_end - 1);
-          self.removal_end -= 1;
-          Some(removed)
-        }
-      }
-    } else {
-      None
-    }
-  }
-}
-
-impl<'p, A: Array, I: Iterator<Item = A::Item>> Drop
-  for TinyVecSplice<'p, A, I>
-{
-  #[inline]
-  fn drop(&mut self) {
-    for _ in self.by_ref() {}
-
-    let (lower_bound, _) = self.replacement.size_hint();
-    self.parent.reserve(lower_bound);
-
-    for replacement in self.replacement.by_ref() {
-      self.parent.insert(self.removal_end, replacement);
-      self.removal_end += 1;
-    }
-  }
-}
-
-impl<A: Array> AsMut<[A::Item]> for TinyVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn as_mut(&mut self) -> &mut [A::Item] {
-    &mut *self
-  }
-}
-
-impl<A: Array> AsRef<[A::Item]> for TinyVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn as_ref(&self) -> &[A::Item] {
-    &*self
-  }
-}
-
-impl<A: Array> Borrow<[A::Item]> for TinyVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn borrow(&self) -> &[A::Item] {
-    &*self
-  }
-}
-
-impl<A: Array> BorrowMut<[A::Item]> for TinyVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn borrow_mut(&mut self) -> &mut [A::Item] {
-    &mut *self
-  }
-}
-
-impl<A: Array> Extend<A::Item> for TinyVec<A> {
-  #[inline]
-  fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T) {
-    let iter = iter.into_iter();
-    let (lower_bound, _) = iter.size_hint();
-    self.reserve(lower_bound);
-
-    let a = match self {
-      TinyVec::Heap(h) => return h.extend(iter),
-      TinyVec::Inline(a) => a,
-    };
-
-    let mut iter = a.fill(iter);
-    let maybe = iter.next();
-
-    let surely = match maybe {
-      Some(x) => x,
-      None => return,
-    };
-
-    let mut v = a.drain_to_vec_and_reserve(a.len());
-    v.push(surely);
-    v.extend(iter);
-    *self = TinyVec::Heap(v);
-  }
-}
-
-impl<A: Array> From<ArrayVec<A>> for TinyVec<A> {
-  #[inline(always)]
-  #[must_use]
-  fn from(arr: ArrayVec<A>) -> Self {
-    TinyVec::Inline(arr)
-  }
-}
-
-impl<A: Array> From<A> for TinyVec<A> {
-  #[inline]
-  fn from(array: A) -> Self {
-    TinyVec::Inline(ArrayVec::from(array))
-  }
-}
-
-impl<T, A> From<&'_ [T]> for TinyVec<A>
-where
-  T: Clone + Default,
-  A: Array<Item = T>,
-{
-  #[inline]
-  #[must_use]
-  fn from(slice: &[T]) -> Self {
-    if let Ok(arr) = ArrayVec::try_from(slice) {
-      TinyVec::Inline(arr)
-    } else {
-      TinyVec::Heap(slice.into())
-    }
-  }
-}
-
-impl<T, A> From<&'_ mut [T]> for TinyVec<A>
-where
-  T: Clone + Default,
-  A: Array<Item = T>,
-{
-  #[inline]
-  #[must_use]
-  fn from(slice: &mut [T]) -> Self {
-    Self::from(&*slice)
-  }
-}
-
-impl<A: Array> FromIterator<A::Item> for TinyVec<A> {
-  #[inline]
-  #[must_use]
-  fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self {
-    let mut av = Self::default();
-    av.extend(iter);
-    av
-  }
-}
-
-impl<A: Array> Into<Vec<A::Item>> for TinyVec<A> {
-  /// Converts a `TinyVec` into a `Vec`.
-  ///
-  /// ## Examples
-  ///
-  /// ### Inline to Vec
-  ///
-  /// For `TinyVec::Inline(_)`,
-  ///   `.into()` **does not** offer a performance advantage over `.to_vec()`.
-  ///
-  /// ```
-  /// use core::mem::size_of_val as mem_size_of;
-  /// use tinyvec::TinyVec;
-  ///
-  /// let v = TinyVec::from([0u8; 128]);
-  /// assert_eq!(mem_size_of(&v), 136);
-  ///
-  /// let vec: Vec<_> = v.into();
-  /// assert_eq!(mem_size_of(&vec), 24);
-  /// ```
-  ///
-  /// ### Heap into Vec
-  ///
-  /// For `TinyVec::Heap(vec_data)`,
-  ///   `.into()` will take `vec_data` without heap reallocation.
-  ///
-  /// ```
-  /// use core::{
-  ///   any::type_name_of_val as type_of, mem::size_of_val as mem_size_of,
-  /// };
-  /// use tinyvec::TinyVec;
-  ///
-  /// const fn from_heap<T: Default>(owned: Vec<T>) -> TinyVec<[T; 1]> {
-  ///   TinyVec::Heap(owned)
-  /// }
-  ///
-  /// let v = from_heap(vec![0u8; 128]);
-  /// assert_eq!(v.len(), 128);
-  /// assert_eq!(mem_size_of(&v), 24);
-  /// assert!(type_of(&v).ends_with("TinyVec<[u8; 1]>"));
-  ///
-  /// let vec: Vec<_> = v.into();
-  /// assert_eq!(mem_size_of(&vec), 24);
-  /// assert!(type_of(&vec).ends_with("Vec<u8>"));
-  /// ```
-  #[inline]
-  #[must_use]
-  fn into(self) -> Vec<A::Item> {
-    match self {
-      Self::Heap(inner) => inner,
-      Self::Inline(mut inner) => inner.drain_to_vec(),
-    }
-  }
-}
-
-/// Iterator for consuming an `TinyVec` and returning owned elements.
-#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub enum TinyVecIterator<A: Array> {
-  #[allow(missing_docs)]
-  Inline(ArrayVecIterator<A>),
-  #[allow(missing_docs)]
-  Heap(alloc::vec::IntoIter<A::Item>),
-}
-
-impl<A: Array> TinyVecIterator<A> {
-  impl_mirrored! {
-    type Mirror = TinyVecIterator;
-    /// Returns the remaining items of this iterator as a slice.
-    #[inline]
-    #[must_use]
-    pub fn as_slice(self: &Self) -> &[A::Item];
-  }
-}
-
-impl<A: Array> FusedIterator for TinyVecIterator<A> {}
-
-impl<A: Array> Iterator for TinyVecIterator<A> {
-  type Item = A::Item;
-
-  impl_mirrored! {
-    type Mirror = TinyVecIterator;
-
-    #[inline]
-    fn next(self: &mut Self) -> Option<Self::Item>;
-
-    #[inline(always)]
-    #[must_use]
-    fn size_hint(self: &Self) -> (usize, Option<usize>);
-
-    #[inline(always)]
-    fn count(self: Self) -> usize;
-
-    #[inline]
-    fn last(self: Self) -> Option<Self::Item>;
-
-    #[inline]
-    fn nth(self: &mut Self, n: usize) -> Option<A::Item>;
-  }
-}
-
-impl<A: Array> DoubleEndedIterator for TinyVecIterator<A> {
-  impl_mirrored! {
-    type Mirror = TinyVecIterator;
-
-    #[inline]
-    fn next_back(self: &mut Self) -> Option<Self::Item>;
-
-    #[inline]
-    fn nth_back(self: &mut Self, n: usize) -> Option<Self::Item>;
-  }
-}
-
-impl<A: Array> ExactSizeIterator for TinyVecIterator<A> {
-  impl_mirrored! {
-    type Mirror = TinyVecIterator;
-    #[inline]
-    fn len(self: &Self) -> usize;
-  }
-}
-
-impl<A: Array> Debug for TinyVecIterator<A>
-where
-  A::Item: Debug,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-    f.debug_tuple("TinyVecIterator").field(&self.as_slice()).finish()
-  }
-}
-
-impl<A: Array> IntoIterator for TinyVec<A> {
-  type Item = A::Item;
-  type IntoIter = TinyVecIterator<A>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    match self {
-      TinyVec::Inline(a) => TinyVecIterator::Inline(a.into_iter()),
-      TinyVec::Heap(v) => TinyVecIterator::Heap(v.into_iter()),
-    }
-  }
-}
-
-impl<'a, A: Array> IntoIterator for &'a mut TinyVec<A> {
-  type Item = &'a mut A::Item;
-  type IntoIter = core::slice::IterMut<'a, A::Item>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    self.iter_mut()
-  }
-}
-
-impl<'a, A: Array> IntoIterator for &'a TinyVec<A> {
-  type Item = &'a A::Item;
-  type IntoIter = core::slice::Iter<'a, A::Item>;
-  #[inline(always)]
-  #[must_use]
-  fn into_iter(self) -> Self::IntoIter {
-    self.iter()
-  }
-}
-
-impl<A: Array> PartialEq for TinyVec<A>
-where
-  A::Item: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &Self) -> bool {
-    self.as_slice().eq(other.as_slice())
-  }
-}
-impl<A: Array> Eq for TinyVec<A> where A::Item: Eq {}
-
-impl<A: Array> PartialOrd for TinyVec<A>
-where
-  A::Item: PartialOrd,
-{
-  #[inline]
-  #[must_use]
-  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-    self.as_slice().partial_cmp(other.as_slice())
-  }
-}
-impl<A: Array> Ord for TinyVec<A>
-where
-  A::Item: Ord,
-{
-  #[inline]
-  #[must_use]
-  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
-    self.as_slice().cmp(other.as_slice())
-  }
-}
-
-impl<A: Array> PartialEq<&A> for TinyVec<A>
-where
-  A::Item: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &&A) -> bool {
-    self.as_slice().eq(other.as_slice())
-  }
-}
-
-impl<A: Array> PartialEq<&[A::Item]> for TinyVec<A>
-where
-  A::Item: PartialEq,
-{
-  #[inline]
-  #[must_use]
-  fn eq(&self, other: &&[A::Item]) -> bool {
-    self.as_slice().eq(*other)
-  }
-}
-
-impl<A: Array> Hash for TinyVec<A>
-where
-  A::Item: Hash,
-{
-  #[inline]
-  fn hash<H: Hasher>(&self, state: &mut H) {
-    self.as_slice().hash(state)
-  }
-}
-
-// // // // // // // //
-// Formatting impls
-// // // // // // // //
-
-impl<A: Array> Binary for TinyVec<A>
-where
-  A::Item: Binary,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Binary::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Debug for TinyVec<A>
-where
-  A::Item: Debug,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() && !self.is_empty() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Debug::fmt(elem, f)?;
-    }
-    if f.alternate() && !self.is_empty() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Display for TinyVec<A>
-where
-  A::Item: Display,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Display::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> LowerExp for TinyVec<A>
-where
-  A::Item: LowerExp,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      LowerExp::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> LowerHex for TinyVec<A>
-where
-  A::Item: LowerHex,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      LowerHex::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Octal for TinyVec<A>
-where
-  A::Item: Octal,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Octal::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> Pointer for TinyVec<A>
-where
-  A::Item: Pointer,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      Pointer::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> UpperExp for TinyVec<A>
-where
-  A::Item: UpperExp,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      UpperExp::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-impl<A: Array> UpperHex for TinyVec<A>
-where
-  A::Item: UpperHex,
-{
-  #[allow(clippy::missing_inline_in_public_items)]
-  fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
-    write!(f, "[")?;
-    if f.alternate() {
-      write!(f, "\n    ")?;
-    }
-    for (i, elem) in self.iter().enumerate() {
-      if i > 0 {
-        write!(f, ",{}", if f.alternate() { "\n    " } else { " " })?;
-      }
-      UpperHex::fmt(elem, f)?;
-    }
-    if f.alternate() {
-      write!(f, ",\n")?;
-    }
-    write!(f, "]")
-  }
-}
-
-#[cfg(feature = "serde")]
-#[cfg_attr(docs_rs, doc(cfg(feature = "alloc")))]
-struct TinyVecVisitor<A: Array>(PhantomData<A>);
-
-#[cfg(feature = "serde")]
-impl<'de, A: Array> Visitor<'de> for TinyVecVisitor<A>
-where
-  A::Item: Deserialize<'de>,
-{
-  type Value = TinyVec<A>;
-
-  fn expecting(
-    &self, formatter: &mut core::fmt::Formatter,
-  ) -> core::fmt::Result {
-    formatter.write_str("a sequence")
-  }
-
-  fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
-  where
-    S: SeqAccess<'de>,
-  {
-    let mut new_tinyvec = match seq.size_hint() {
-      Some(expected_size) => TinyVec::with_capacity(expected_size),
-      None => Default::default(),
-    };
-
-    while let Some(value) = seq.next_element()? {
-      new_tinyvec.push(value);
-    }
-
-    Ok(new_tinyvec)
-  }
-}
diff --git a/third_party/rust/tinyvec/tests/arrayvec.rs b/third_party/rust/tinyvec/tests/arrayvec.rs
@@ -1,500 +0,0 @@
-#![allow(bad_style)]
-#![allow(clippy::clone_on_copy)]
-
-#[cfg(feature = "serde")]
-use serde_test::{assert_tokens, Token};
-use std::iter::FromIterator;
-use tinyvec::*;
-
-#[test]
-fn test_a_vec() {
-  let mut expected: ArrayVec<[i32; 4]> = Default::default();
-  expected.push(1);
-  expected.push(2);
-  expected.push(3);
-
-  let actual = array_vec!(1, 2, 3);
-
-  assert_eq!(expected, actual);
-
-  assert_eq!(array_vec![0u8; 4], array_vec!(0u8, 0u8, 0u8, 0u8));
-  assert_eq!(array_vec![0u8; 4], array_vec!([u8; 4] => 0, 0, 0, 0));
-  assert_eq!(array_vec![0; 4], array_vec!(0, 0, 0, 0));
-  assert_eq!(array_vec![0; 4], array_vec!([u8; 4] => 0, 0, 0, 0));
-
-  let expected2 = array_vec![1.1; 3];
-  let actual2 = array_vec!([f32; 3] => 1.1, 1.1, 1.1);
-  assert_eq!(expected2, actual2);
-}
-
-#[test]
-fn ArrayVec_push_pop() {
-  let mut av: ArrayVec<[i32; 4]> = Default::default();
-  assert_eq!(av.len(), 0);
-  assert_eq!(av.pop(), None);
-
-  av.push(10_i32);
-  assert_eq!(av.len(), 1);
-  assert_eq!(av[0], 10);
-  assert_eq!(av.pop(), Some(10));
-  assert_eq!(av.len(), 0);
-  assert_eq!(av.pop(), None);
-
-  av.push(10);
-  av.push(11);
-  av.push(12);
-  av.push(13);
-  assert_eq!(av[0], 10);
-  assert_eq!(av[1], 11);
-  assert_eq!(av[2], 12);
-  assert_eq!(av[3], 13);
-  assert_eq!(av.len(), 4);
-  assert_eq!(av.pop(), Some(13));
-  assert_eq!(av.len(), 3);
-  assert_eq!(av.pop(), Some(12));
-  assert_eq!(av.len(), 2);
-  assert_eq!(av.pop(), Some(11));
-  assert_eq!(av.len(), 1);
-  assert_eq!(av.pop(), Some(10));
-  assert_eq!(av.len(), 0);
-  assert_eq!(av.pop(), None);
-}
-
-#[test]
-#[should_panic]
-fn ArrayVec_push_overflow() {
-  let mut av: ArrayVec<[i32; 0]> = Default::default();
-  av.push(7);
-}
-
-#[test]
-fn ArrayVec_formatting() {
-  // check that we get the comma placement correct
-
-  let mut av: ArrayVec<[i32; 4]> = Default::default();
-  assert_eq!(format!("{:?}", av), "[]");
-  av.push(10);
-  assert_eq!(format!("{:?}", av), "[10]");
-  av.push(11);
-  assert_eq!(format!("{:?}", av), "[10, 11]");
-  av.push(12);
-  assert_eq!(format!("{:?}", av), "[10, 11, 12]");
-
-  // below here just asserts that the impls exist.
-
-  //
-  let av: ArrayVec<[i32; 4]> = Default::default();
-  assert_eq!(format!("{:b}", av), "[]");
-  assert_eq!(format!("{:o}", av), "[]");
-  assert_eq!(format!("{:x}", av), "[]");
-  assert_eq!(format!("{:X}", av), "[]");
-  assert_eq!(format!("{}", av), "[]");
-  //
-  let av: ArrayVec<[f32; 4]> = Default::default();
-  assert_eq!(format!("{:e}", av), "[]");
-  assert_eq!(format!("{:E}", av), "[]");
-  //
-  let av: ArrayVec<[&'static str; 4]> = Default::default();
-  assert_eq!(format!("{:p}", av), "[]");
-}
-
-#[test]
-fn ArrayVec_iteration() {
-  let av = array_vec!([i32; 4] => 10, 11, 12, 13);
-
-  let mut i = av.into_iter();
-  assert_eq!(i.next(), Some(10));
-  assert_eq!(i.next(), Some(11));
-  assert_eq!(i.next(), Some(12));
-  assert_eq!(i.next(), Some(13));
-  assert_eq!(i.next(), None);
-
-  let av = array_vec!([i32; 4] => 10, 11, 12, 13);
-
-  let mut av2: ArrayVec<[i32; 4]> = av.clone().into_iter().collect();
-  assert_eq!(av, av2);
-
-  // IntoIterator for &mut ArrayVec
-  for x in &mut av2 {
-    *x = -*x;
-  }
-
-  // IntoIterator for &ArrayVec
-  assert!(av.iter().zip(&av2).all(|(&a, &b)| a == -b));
-}
-
-#[test]
-fn ArrayVec_append() {
-  let mut av = array_vec!([i32; 8] => 1, 2, 3);
-  let mut av2 = array_vec!([i32; 8] => 4, 5, 6);
-  //
-  av.append(&mut av2);
-  assert_eq!(av.as_slice(), &[1_i32, 2, 3, 4, 5, 6]);
-  assert_eq!(av2.as_slice(), &[]);
-}
-
-#[test]
-fn ArrayVec_remove() {
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-  assert_eq!(av.remove(1), 2);
-  assert_eq!(&av[..], &[1, 3][..]);
-}
-
-#[test]
-#[should_panic]
-fn ArrayVec_remove_invalid() {
-  let mut av: ArrayVec<[i32; 1]> = Default::default();
-  av.push(1);
-  av.remove(1);
-}
-
-#[test]
-fn ArrayVec_swap_remove() {
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-  av.push(4);
-  assert_eq!(av.swap_remove(3), 4);
-  assert_eq!(&av[..], &[1, 2, 3][..]);
-  assert_eq!(av.swap_remove(0), 1);
-  assert_eq!(&av[..], &[3, 2][..]);
-  assert_eq!(av.swap_remove(0), 3);
-  assert_eq!(&av[..], &[2][..]);
-  assert_eq!(av.swap_remove(0), 2);
-  assert_eq!(&av[..], &[][..]);
-}
-
-#[test]
-fn ArrayVec_drain() {
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-
-  assert_eq!(Vec::from_iter(av.clone().drain(..)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().drain(..2)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().drain(..3)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().drain(..=1)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().drain(..=2)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().drain(0..)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(av.clone().drain(1..)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().drain(0..2)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().drain(0..3)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(av.clone().drain(1..2)), vec![2]);
-  assert_eq!(Vec::from_iter(av.clone().drain(1..3)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().drain(0..=1)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().drain(0..=2)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(av.clone().drain(1..=1)), vec![2]);
-  assert_eq!(Vec::from_iter(av.clone().drain(1..=2)), vec![2, 3]);
-}
-
-#[test]
-fn ArrayVec_splice() {
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-
-  // splice returns the same things as drain
-  assert_eq!(Vec::from_iter(av.clone().splice(.., None)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().splice(..2, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().splice(..3, None)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().splice(..=1, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().splice(..=2, None)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().splice(0.., None)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(av.clone().splice(1.., None)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().splice(0..2, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().splice(0..3, None)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(av.clone().splice(1..2, None)), vec![2]);
-  assert_eq!(Vec::from_iter(av.clone().splice(1..3, None)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(av.clone().splice(0..=1, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(av.clone().splice(0..=2, None)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(av.clone().splice(1..=1, None)), vec![2]);
-  assert_eq!(Vec::from_iter(av.clone().splice(1..=2, None)), vec![2, 3]);
-
-  // splice removes the same things as drain
-  let mut av2 = av.clone();
-  av2.splice(.., None);
-  assert_eq!(av2, array_vec![]);
-
-  let mut av2 = av.clone();
-  av2.splice(..2, None);
-  assert_eq!(av2, array_vec![3]);
-
-  let mut av2 = av.clone();
-  av2.splice(..3, None);
-  assert_eq!(av2, array_vec![]);
-
-  let mut av2 = av.clone();
-  av2.splice(..=1, None);
-  assert_eq!(av2, array_vec![3]);
-  let mut av2 = av.clone();
-  av2.splice(..=2, None);
-  assert_eq!(av2, array_vec![]);
-
-  let mut av2 = av.clone();
-  av2.splice(0.., None);
-  assert_eq!(av2, array_vec![]);
-  let mut av2 = av.clone();
-  av2.splice(1.., None);
-  assert_eq!(av2, array_vec![1]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..2, None);
-  assert_eq!(av2, array_vec![3]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..3, None);
-  assert_eq!(av2, array_vec![]);
-  let mut av2 = av.clone();
-  av2.splice(1..2, None);
-  assert_eq!(av2, array_vec![1, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..3, None);
-  assert_eq!(av2, array_vec![1]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..=1, None);
-  assert_eq!(av2, array_vec![3]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..=2, None);
-  assert_eq!(av2, array_vec![]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..=1, None);
-  assert_eq!(av2, array_vec![1, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..=2, None);
-  assert_eq!(av2, array_vec![1]);
-
-  // splice adds the elements correctly
-  let mut av2 = av.clone();
-  av2.splice(.., 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(..2, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(..3, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(..=1, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(..=2, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(0.., 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(1.., 4..=6);
-  assert_eq!(av2, array_vec![1, 4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..2, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..3, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..2, 4..=6);
-  assert_eq!(av2, array_vec![1, 4, 5, 6, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..3, 4..=6);
-  assert_eq!(av2, array_vec![1, 4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..=1, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(0..=2, 4..=6);
-  assert_eq!(av2, array_vec![4, 5, 6]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..=1, 4..=6);
-  assert_eq!(av2, array_vec![1, 4, 5, 6, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..=2, 4..=6);
-  assert_eq!(av2, array_vec![1, 4, 5, 6]);
-
-  // splice adds the elements correctly when the replacement is smaller
-  let mut av2 = av.clone();
-  av2.splice(.., Some(4));
-  assert_eq!(av2, array_vec![4]);
-
-  let mut av2 = av.clone();
-  av2.splice(..2, Some(4));
-  assert_eq!(av2, array_vec![4, 3]);
-
-  let mut av2 = av.clone();
-  av2.splice(1.., Some(4));
-  assert_eq!(av2, array_vec![1, 4]);
-
-  let mut av2 = av.clone();
-  av2.splice(1..=1, Some(4));
-  assert_eq!(av2, array_vec![1, 4, 3]);
-}
-
-#[test]
-fn iter_last_nth() {
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-  av.push(4);
-  assert_eq!(av.len(), 4);
-  let mut iter = av.into_iter();
-  assert_eq!(iter.next(), Some(1));
-  assert_eq!(iter.next(), Some(2));
-  assert_eq!(iter.next(), Some(3));
-  assert_eq!(iter.next(), Some(4));
-  assert_eq!(iter.next(), None);
-  assert_eq!(iter.last(), None);
-
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-
-  assert_eq!(av.into_iter().next(), Some(1));
-}
-
-#[test]
-#[cfg(feature = "rustc_1_40")]
-fn reviter() {
-  let mut av: ArrayVec<[i32; 10]> = Default::default();
-  av.push(1);
-  av.push(2);
-  av.push(3);
-  av.push(4);
-
-  let mut iter = av.into_iter();
-
-  assert_eq!(iter.next(), Some(1));
-  assert_eq!(iter.next_back(), Some(4));
-  assert_eq!(iter.next(), Some(2));
-  assert_eq!(iter.next_back(), Some(3));
-  assert_eq!(iter.next(), None);
-  assert_eq!(iter.next_back(), None);
-
-  let mut av: ArrayVec<[i32; 32]> = Default::default();
-  av.extend(0..32);
-
-  let mut iter = av.into_iter();
-
-  assert_eq!(iter.nth_back(0), Some(31));
-  assert_eq!(iter.nth_back(2), Some(28));
-  assert_eq!(iter.nth_back(0), Some(27));
-  assert_eq!(iter.nth_back(99), None);
-  assert_eq!(iter.nth_back(99), None);
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn ArrayVec_ser_de_empty() {
-  let tv: ArrayVec<[i32; 0]> = Default::default();
-
-  assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn ArrayVec_ser_de() {
-  let mut tv: ArrayVec<[i32; 4]> = Default::default();
-  tv.push(1);
-  tv.push(2);
-  tv.push(3);
-  tv.push(4);
-
-  assert_tokens(
-    &tv,
-    &[
-      Token::Seq { len: Some(4) },
-      Token::I32(1),
-      Token::I32(2),
-      Token::I32(3),
-      Token::I32(4),
-      Token::SeqEnd,
-    ],
-  );
-}
-
-#[cfg(feature = "borsh")]
-#[test]
-fn ArrayVec_borsh_de_empty() {
-  let tv: ArrayVec<[i32; 0]> = Default::default();
-  let buffer = borsh::to_vec(&tv).unwrap();
-  let des: ArrayVec<[i32; 0]> = borsh::from_slice(&buffer).unwrap();
-  assert_eq!(tv, des);
-}
-
-#[cfg(feature = "borsh")]
-#[test]
-fn ArrayVec_borsh_de() {
-  let mut tv: ArrayVec<[i32; 4]> = Default::default();
-  tv.push(1);
-  tv.push(2);
-  tv.push(3);
-  tv.push(4);
-  let buffer = borsh::to_vec(&tv).unwrap();
-  let des: ArrayVec<[i32; 4]> = borsh::from_slice(&buffer).unwrap();
-  assert_eq!(tv, des);
-}
-
-#[test]
-fn ArrayVec_try_from_slice() {
-  use std::convert::TryFrom;
-
-  let nums = [1, 2, 3, 4];
-
-  let empty: Result<ArrayVec<[i32; 2]>, _> = ArrayVec::try_from(&nums[..0]);
-  assert!(empty.is_ok());
-  assert_eq!(empty.unwrap().as_slice(), &[]);
-
-  let fits: Result<ArrayVec<[i32; 2]>, _> = ArrayVec::try_from(&nums[..2]);
-  assert!(fits.is_ok());
-  assert_eq!(fits.unwrap().as_slice(), &[1, 2]);
-
-  let does_not_fit: Result<ArrayVec<[i32; 2]>, _> =
-    ArrayVec::try_from(&nums[..4]);
-  assert!(does_not_fit.is_err());
-}
-
-#[test]
-fn ArrayVec_pretty_debug() {
-  let arr: [i32; 3] = [1, 2, 3];
-  let expect = format!("{:#?}", arr);
-
-  let arr: ArrayVec<[i32; 3]> = array_vec![1, 2, 3];
-  let got = format!("{:#?}", arr);
-
-  assert_eq!(got, expect);
-}
diff --git a/third_party/rust/tinyvec/tests/debugger_visualizer.rs b/third_party/rust/tinyvec/tests/debugger_visualizer.rs
@@ -1,91 +0,0 @@
-use debugger_test::debugger_test;
-use tinyvec::*;
-
-#[inline(never)]
-fn __break() {
-  println!("breakpoint hit");
-}
-
-#[debugger_test(
-  debugger = "cdb",
-  commands = r#"
-dx strings
-dx inline_tv
-dx inline_tv.__0
-g
-dx slice_vec
-g
-dx strings
-"#,
-  expected_statements = r#"
-pattern:strings          : \{ len=0x3 \} \[Type: tinyvec::arrayvec::ArrayVec<array\$<.*str.*,7> >\]
-pattern:\[<Raw View>\]     \[Type: tinyvec::arrayvec::ArrayVec<array\$<.*str.*,7> >\]
-pattern:\[len\]            : 0x3 \[Type: unsigned short\]
-pattern:\[capacity\]       : 7
-pattern:\[0\]              : "a" \[Type: .*str.*\]
-pattern:\[1\]              : "b" \[Type: .*str.*\]
-pattern:\[2\]              : "c" \[Type: .*str.*\]
-
-inline_tv        : Inline [Type: enum2$<tinyvec::tinyvec::TinyVec<array$<i32,4> > >]
-    [<Raw View>]     [Type: enum2$<tinyvec::tinyvec::TinyVec<array$<i32,4> > >]
-    [+0x004] __0              : { len=0x4 } [Type: tinyvec::arrayvec::ArrayVec<array$<i32,4> >]
-
-inline_tv.__0    : { len=0x4 } [Type: tinyvec::arrayvec::ArrayVec<array$<i32,4> >]
-    [<Raw View>]     [Type: tinyvec::arrayvec::ArrayVec<array$<i32,4> >]
-    [len]            : 0x4 [Type: unsigned short]
-    [capacity]       : 4
-    [0]              : 1 [Type: i32]
-    [1]              : 2 [Type: i32]
-    [2]              : 3 [Type: i32]
-    [3]              : 4 [Type: i32]
-
-pattern:slice_vec        : \{ len=0x3 \} \[Type: tinyvec::slicevec::SliceVec<.*str.*>\]
-pattern:\[<Raw View>\]     \[Type: tinyvec::slicevec::SliceVec<.*str.*>\]
-pattern:\[len\]            : 0x3 \[Type: unsigned __int64\]
-pattern:\[0\]              : "a" \[Type: .*str.*\]
-pattern:\[1\]              : "b" \[Type: .*str.*\]
-pattern:\[2\]              : "d" \[Type: .*str.*\]
-
-pattern:strings          : \{ len=0x6 \} \[Type: tinyvec::arrayvec::ArrayVec<array\$<.*str.*,7> >\]
-pattern:\[<Raw View>\]     \[Type: tinyvec::arrayvec::ArrayVec<array\$<.*str.*,7> >\]
-pattern:\[len\]            : 0x6 \[Type: unsigned short\]
-pattern:\[capacity\]       : 7
-pattern:\[0\]              : "a" \[Type: .*str.*\]
-pattern:\[1\]              : "b" \[Type: .*str.*\]
-pattern:\[2\]              : "d" \[Type: .*str.*\]
-pattern:\[3\]              : "e" \[Type: .*str.*\]
-pattern:\[4\]              : "f" \[Type: .*str.*\]
-pattern:\[5\]              : "g" \[Type: .*str.*\]
-"#
-)]
-#[inline(never)]
-fn test_debugger_visualizer() {
-  let mut strings = ArrayVec::<[&str; 7]>::default();
-  strings.push("a");
-  strings.push("b");
-  strings.push("c");
-  assert_eq!(["a", "b", "c"], &strings[..]);
-
-  let mut inline_tv = tiny_vec!([i32; 4] => 1, 2, 3);
-  assert!(inline_tv.is_inline());
-
-  inline_tv.push(4);
-  __break();
-
-  {
-    let mut slice_vec = SliceVec::from(strings.as_mut_slice());
-    assert_eq!(3, slice_vec.capacity());
-    assert_eq!("c", slice_vec.remove(2));
-    slice_vec.push("d");
-    println!("{:?}", slice_vec);
-    __break();
-
-    assert_eq!(["a", "b", "d"], &slice_vec[..]);
-  }
-
-  strings.push("e");
-  strings.push("f");
-  strings.push("g");
-  assert_eq!(["a", "b", "d", "e", "f", "g"], &strings[..]);
-  __break();
-}
diff --git a/third_party/rust/tinyvec/tests/tinyvec.rs b/third_party/rust/tinyvec/tests/tinyvec.rs
@@ -1,501 +0,0 @@
-#![cfg(feature = "alloc")]
-#![allow(bad_style)]
-#![allow(clippy::redundant_clone)]
-
-#[cfg(feature = "serde")]
-use serde_test::{assert_tokens, Token};
-use std::iter::FromIterator;
-use tinyvec::*;
-
-#[test]
-fn TinyVec_swap_remove() {
-  let mut tv: TinyVec<[i32; 10]> = Default::default();
-  tv.push(1);
-  tv.push(2);
-  tv.push(3);
-  tv.push(4);
-  assert_eq!(tv.swap_remove(3), 4);
-  assert_eq!(&tv[..], &[1, 2, 3][..]);
-  assert_eq!(tv.swap_remove(0), 1);
-  assert_eq!(&tv[..], &[3, 2][..]);
-  assert_eq!(tv.swap_remove(0), 3);
-  assert_eq!(&tv[..], &[2][..]);
-  assert_eq!(tv.swap_remove(0), 2);
-  assert_eq!(&tv[..], &[][..]);
-}
-
-#[test]
-fn TinyVec_capacity() {
-  let mut tv: TinyVec<[i32; 1]> = Default::default();
-  assert_eq!(tv.capacity(), 1);
-  tv.move_to_the_heap();
-  tv.extend_from_slice(&[1, 2, 3, 4]);
-  assert_eq!(tv.capacity(), 4);
-}
-
-#[test]
-fn TinyVec_drain() {
-  let mut tv: TinyVec<[i32; 10]> = Default::default();
-  tv.push(1);
-  tv.push(2);
-  tv.push(3);
-
-  assert_eq!(Vec::from_iter(tv.clone().drain(..)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().drain(..2)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(..3)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().drain(..=1)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(..=2)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().drain(0..)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(1..)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().drain(0..2)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(0..3)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(1..2)), vec![2]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(1..3)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().drain(0..=1)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(0..=2)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(1..=1)), vec![2]);
-  assert_eq!(Vec::from_iter(tv.clone().drain(1..=2)), vec![2, 3]);
-}
-
-#[test]
-fn TinyVec_splice() {
-  let mut tv: TinyVec<[i32; 10]> = Default::default();
-  tv.push(1);
-  tv.push(2);
-  tv.push(3);
-
-  // splice returns the same things as drain
-  assert_eq!(Vec::from_iter(tv.clone().splice(.., None)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().splice(..2, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(..3, None)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().splice(..=1, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(..=2, None)), vec![1, 2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().splice(0.., None)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(1.., None)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().splice(0..2, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(0..3, None)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(1..2, None)), vec![2]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(1..3, None)), vec![2, 3]);
-
-  assert_eq!(Vec::from_iter(tv.clone().splice(0..=1, None)), vec![1, 2]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(0..=2, None)), vec![1, 2, 3]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(1..=1, None)), vec![2]);
-  assert_eq!(Vec::from_iter(tv.clone().splice(1..=2, None)), vec![2, 3]);
-
-  // splice removes the same things as drain
-  let mut tv2 = tv.clone();
-  tv2.splice(.., None);
-  assert_eq!(tv2, tiny_vec![]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..2, None);
-  assert_eq!(tv2, tiny_vec![3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..3, None);
-  assert_eq!(tv2, tiny_vec![]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..=1, None);
-  assert_eq!(tv2, tiny_vec![3]);
-  let mut tv2 = tv.clone();
-  tv2.splice(..=2, None);
-  assert_eq!(tv2, tiny_vec![]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0.., None);
-  assert_eq!(tv2, tiny_vec![]);
-  let mut tv2 = tv.clone();
-  tv2.splice(1.., None);
-  assert_eq!(tv2, tiny_vec![1]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..2, None);
-  assert_eq!(tv2, tiny_vec![3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..3, None);
-  assert_eq!(tv2, tiny_vec![]);
-  let mut tv2 = tv.clone();
-  tv2.splice(1..2, None);
-  assert_eq!(tv2, tiny_vec![1, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..3, None);
-  assert_eq!(tv2, tiny_vec![1]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..=1, None);
-  assert_eq!(tv2, tiny_vec![3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..=2, None);
-  assert_eq!(tv2, tiny_vec![]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..=1, None);
-  assert_eq!(tv2, tiny_vec![1, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..=2, None);
-  assert_eq!(tv2, tiny_vec![1]);
-
-  // splice adds the elements correctly
-  let mut tv2 = tv.clone();
-  tv2.splice(.., 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..2, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..3, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..=1, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..=2, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0.., 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1.., 4..=6);
-  assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..2, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..3, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..2, 4..=6);
-  assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..3, 4..=6);
-  assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..=1, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(0..=2, 4..=6);
-  assert_eq!(tv2, tiny_vec![4, 5, 6]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..=1, 4..=6);
-  assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..=2, 4..=6);
-  assert_eq!(tv2, tiny_vec![1, 4, 5, 6]);
-
-  // splice adds the elements correctly when the replacement is smaller
-  let mut tv2 = tv.clone();
-  tv2.splice(.., Some(4));
-  assert_eq!(tv2, tiny_vec![4]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(..2, Some(4));
-  assert_eq!(tv2, tiny_vec![4, 3]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1.., Some(4));
-  assert_eq!(tv2, tiny_vec![1, 4]);
-
-  let mut tv2 = tv.clone();
-  tv2.splice(1..=1, Some(4));
-  assert_eq!(tv2, tiny_vec![1, 4, 3]);
-}
-
-#[test]
-fn TinyVec_resize() {
-  let mut tv: TinyVec<[i32; 10]> = Default::default();
-  tv.resize(20, 5);
-  assert_eq!(&tv[..], &[5; 20]);
-}
-
-#[test]
-fn TinyVec_from_slice_impl() {
-  let bigger_slice: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-  let tinyvec: TinyVec<[u8; 10]> = TinyVec::Heap((&bigger_slice[..]).into());
-  assert_eq!(TinyVec::from(&bigger_slice[..]), tinyvec);
-
-  let smaller_slice: [u8; 5] = [0, 1, 2, 3, 4];
-  let tinyvec: TinyVec<[u8; 10]> = TinyVec::Inline(ArrayVec::from_array_len(
-    [0, 1, 2, 3, 4, 0, 0, 0, 0, 0],
-    5,
-  ));
-  assert_eq!(TinyVec::from(&smaller_slice[..]), tinyvec);
-
-  let same_size: [u8; 4] = [0, 1, 2, 3];
-  let tinyvec: TinyVec<[u8; 4]> =
-    TinyVec::Inline(ArrayVec::from_array_len(same_size, 4));
-  assert_eq!(TinyVec::from(&same_size[..]), tinyvec);
-}
-
-#[test]
-fn TinyVec_from_array() {
-  let array = [9, 8, 7, 6, 5, 4, 3, 2, 1];
-  let tv = TinyVec::from(array);
-  assert_eq!(&array, &tv[..]);
-}
-
-#[test]
-fn TinyVec_macro() {
-  let mut expected: TinyVec<[i32; 4]> = Default::default();
-  expected.push(1);
-  expected.push(2);
-  expected.push(3);
-
-  let actual = tiny_vec!(1, 2, 3);
-
-  assert_eq!(expected, actual);
-
-  assert_eq!(tiny_vec![0u8; 4], tiny_vec!(0u8, 0u8, 0u8, 0u8));
-  assert_eq!(tiny_vec![0u8; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0));
-  assert_eq!(tiny_vec![0; 4], tiny_vec!(0, 0, 0, 0));
-  assert_eq!(tiny_vec![0; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0));
-
-  let expected2 = tiny_vec![1.1; 3];
-  let actual2 = tiny_vec!([f32; 3] => 1.1, 1.1, 1.1);
-  assert_eq!(expected2, actual2);
-}
-
-#[test]
-fn TinyVec_macro_non_copy() {
-  // must use a variable here to avoid macro shenanigans
-  let s = String::new();
-  let _: TinyVec<[String; 10]> = tiny_vec!([String; 10] => s);
-}
-
-#[test]
-fn TinyVec_reserve() {
-  let mut tv: TinyVec<[i32; 4]> = Default::default();
-  assert_eq!(tv.capacity(), 4);
-  tv.extend_from_slice(&[1, 2]);
-  assert_eq!(tv.capacity(), 4);
-  tv.reserve(2);
-  assert_eq!(tv.capacity(), 4);
-  tv.reserve(4);
-  assert!(tv.capacity() >= 6);
-  tv.extend_from_slice(&[3, 4, 5, 6]);
-  tv.reserve(4);
-  assert!(tv.capacity() >= 10);
-}
-
-#[cfg(feature = "rustc_1_57")]
-#[test]
-fn TinyVec_try_reserve() {
-  let mut tv: TinyVec<[i32; 4]> = Default::default();
-  assert_eq!(tv.capacity(), 4);
-  tv.extend_from_slice(&[1, 2]);
-  assert_eq!(tv.capacity(), 4);
-  assert!(tv.try_reserve(2).is_ok());
-  assert_eq!(tv.capacity(), 4);
-  assert!(tv.try_reserve(4).is_ok());
-  assert!(tv.capacity() >= 6);
-  tv.extend_from_slice(&[3, 4, 5, 6]);
-  assert!(tv.try_reserve(4).is_ok());
-  assert!(tv.capacity() >= 10);
-}
-
-#[test]
-fn TinyVec_reserve_exact() {
-  let mut tv: TinyVec<[i32; 4]> = Default::default();
-  assert_eq!(tv.capacity(), 4);
-
-  tv.extend_from_slice(&[1, 2]);
-  assert_eq!(tv.capacity(), 4);
-  tv.reserve_exact(2);
-  assert_eq!(tv.capacity(), 4);
-  tv.reserve_exact(4);
-  assert!(tv.capacity() >= 6);
-  tv.extend_from_slice(&[3, 4, 5, 6]);
-  tv.reserve_exact(4);
-  assert!(tv.capacity() >= 10);
-}
-
-#[cfg(feature = "rustc_1_57")]
-#[test]
-fn TinyVec_try_reserve_exact() {
-  let mut tv: TinyVec<[i32; 4]> = Default::default();
-  assert_eq!(tv.capacity(), 4);
-
-  tv.extend_from_slice(&[1, 2]);
-  assert_eq!(tv.capacity(), 4);
-  assert!(tv.try_reserve_exact(2).is_ok());
-  assert_eq!(tv.capacity(), 4);
-  assert!(tv.try_reserve_exact(4).is_ok());
-  assert!(tv.capacity() >= 6);
-  tv.extend_from_slice(&[3, 4, 5, 6]);
-  assert!(tv.try_reserve_exact(4).is_ok());
-  assert!(tv.capacity() >= 10);
-}
-
-#[test]
-fn TinyVec_move_to_heap_and_shrink() {
-  let mut tv: TinyVec<[i32; 4]> = Default::default();
-  assert!(tv.is_inline());
-  tv.move_to_the_heap();
-  assert!(tv.is_heap());
-  assert_eq!(tv.capacity(), 0);
-
-  tv.push(1);
-  tv.shrink_to_fit();
-  assert!(tv.is_inline());
-  assert_eq!(tv.capacity(), 4);
-
-  tv.move_to_the_heap_and_reserve(3);
-  assert!(tv.is_heap());
-  assert_eq!(tv.capacity(), 4);
-  tv.extend(2..=4);
-  assert_eq!(tv.capacity(), 4);
-  assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
-}
-
-#[cfg(feature = "rustc_1_57")]
-#[test]
-fn TinyVec_try_move_to_heap_and_shrink() {
-  let mut tv: TinyVec<[i32; 4]> = Default::default();
-  assert!(tv.is_inline());
-  assert!(tv.try_move_to_the_heap().is_ok());
-  assert!(tv.is_heap());
-  assert_eq!(tv.capacity(), 0);
-
-  assert!(tv.try_reserve_exact(1).is_ok());
-  assert_eq!(tv.capacity(), 1);
-  tv.push(1);
-  tv.shrink_to_fit();
-  assert!(tv.is_inline());
-  assert_eq!(tv.capacity(), 4);
-
-  assert!(tv.try_move_to_the_heap_and_reserve(3).is_ok());
-  assert!(tv.is_heap());
-  assert_eq!(tv.capacity(), 4);
-  tv.extend(2..=4);
-  assert_eq!(tv.capacity(), 4);
-  assert_eq!(tv.as_slice(), [1, 2, 3, 4]);
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn TinyVec_ser_de_empty() {
-  let tv: TinyVec<[i32; 0]> = tiny_vec![];
-
-  assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn TinyVec_ser_de() {
-  let tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
-
-  assert_tokens(
-    &tv,
-    &[
-      Token::Seq { len: Some(4) },
-      Token::I32(1),
-      Token::I32(2),
-      Token::I32(3),
-      Token::I32(4),
-      Token::SeqEnd,
-    ],
-  );
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn TinyVec_ser_de_heap() {
-  let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
-  tv.move_to_the_heap();
-
-  assert_tokens(
-    &tv,
-    &[
-      Token::Seq { len: Some(4) },
-      Token::I32(1),
-      Token::I32(2),
-      Token::I32(3),
-      Token::I32(4),
-      Token::SeqEnd,
-    ],
-  );
-}
-
-#[cfg(feature = "borsh")]
-#[test]
-fn TinyVec_borsh_de_empty() {
-  let tv: ArrayVec<[i32; 0]> = Default::default();
-  let buffer = borsh::to_vec(&tv).unwrap();
-  let des: ArrayVec<[i32; 0]> = borsh::from_slice(&buffer).unwrap();
-  assert_eq!(tv, des);
-}
-
-#[cfg(feature = "borsh")]
-#[test]
-fn TinyVec_borsh_de() {
-  let mut tv: ArrayVec<[i32; 4]> = Default::default();
-  tv.push(1);
-  tv.push(2);
-  tv.push(3);
-  tv.push(4);
-  let buffer = borsh::to_vec(&tv).unwrap();
-  let des: ArrayVec<[i32; 4]> = borsh::from_slice(&buffer).unwrap();
-  assert_eq!(tv, des);
-}
-
-#[cfg(feature = "borsh")]
-#[test]
-fn TinyVec_borsh_de_heap() {
-  let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4];
-  tv.move_to_the_heap();
-
-  let buffer = borsh::to_vec(&tv).unwrap();
-  let des: TinyVec<[i32; 4]> = borsh::from_slice(&buffer).unwrap();
-  assert_eq!(tv, des);
-}
-
-#[test]
-fn TinyVec_pretty_debug() {
-  let tv: TinyVec<[i32; 6]> = tiny_vec![1, 2, 3];
-  let s = format!("{:#?}", tv);
-  let expected = format!("{:#?}", tv.as_slice());
-
-  assert_eq!(s, expected);
-}
-
-#[cfg(feature = "std")]
-#[test]
-fn TinyVec_std_io_write() {
-  use std::io::Write;
-  let mut tv: TinyVec<[u8; 3]> = TinyVec::new();
-
-  tv.write_all(b"foo").ok();
-  assert!(tv.is_inline());
-  assert_eq!(tv, tiny_vec![b'f', b'o', b'o']);
-
-  tv.write_all(b"bar").ok();
-  assert!(tv.is_heap());
-  assert_eq!(tv, tiny_vec![b'f', b'o', b'o', b'b', b'a', b'r']);
-}
diff --git a/third_party/rust/tinyvec_macros/.cargo-checksum.json b/third_party/rust/tinyvec_macros/.cargo-checksum.json
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"104cb36d7a1c9f2b345883f74e8d49f6cdfab9b44d00516934cdc1476ed1cc44","LICENSE-APACHE.md":"4f44572785f35152c1fd2eadf565b7e079c0f300b4324f0af653419f9d76b735","LICENSE-MIT.md":"1dd8eca0f83669e75fa119e34fb9e1be9d16e3e9b6368962b8019db6e8ae5f7b","LICENSE-ZLIB.md":"41ace205715d9f19a3214218cc1c01d57c533e02cd0fef7c8e51a49a7fce5ac5","src/lib.rs":"8e79346da033b3441987b45e8d8530dd48441aa5d5addaeec5650ce7a0f64dc0"},"package":"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"}
-\ No newline at end of file
diff --git a/third_party/rust/tinyvec_macros/Cargo.toml b/third_party/rust/tinyvec_macros/Cargo.toml
@@ -1,19 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-name = "tinyvec_macros"
-version = "0.1.1"
-authors = ["Soveu <marx.tomasz@gmail.com>"]
-description = "Some macros for tiny containers"
-license = "MIT OR Apache-2.0 OR Zlib"
-repository = "https://github.com/Soveu/tinyvec_macros"
diff --git a/third_party/rust/tinyvec_macros/LICENSE-APACHE.md b/third_party/rust/tinyvec_macros/LICENSE-APACHE.md
@@ -1,202 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2020 Tomasz "Soveu" Marx
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
diff --git a/third_party/rust/tinyvec_macros/LICENSE-MIT.md b/third_party/rust/tinyvec_macros/LICENSE-MIT.md
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Soveu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/third_party/rust/tinyvec_macros/LICENSE-ZLIB.md b/third_party/rust/tinyvec_macros/LICENSE-ZLIB.md
@@ -1,20 +0,0 @@
-zlib License
-
-(C) 2020 Tomasz "Soveu" Marx
-
-This software is provided 'as-is', without any express or implied
-warranty.  In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not
-   claim that you wrote the original software. If you use this software
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-
diff --git a/third_party/rust/tinyvec_macros/src/lib.rs b/third_party/rust/tinyvec_macros/src/lib.rs
@@ -1,25 +0,0 @@
-#![no_std]
-#![forbid(unsafe_code)]
-
-#[macro_export]
-macro_rules! impl_mirrored {
-    {
-    type Mirror = $tinyname:ident;
-    $(
-        $(#[$attr:meta])*
-        $v:vis fn $fname:ident ($seif:ident : $seifty:ty $(,$argname:ident : $argtype:ty)*) $(-> $ret:ty)? ;
-    )*
-    } => {
-        $(
-        $(#[$attr])*
-        #[inline(always)]
-        $v fn $fname($seif : $seifty, $($argname: $argtype),*) $(-> $ret)? {
-            match $seif {
-                $tinyname::Inline(i) => i.$fname($($argname),*),
-                $tinyname::Heap(h) => h.$fname($($argname),*),
-            }
-        }
-        )*
-    };
-}
-
diff --git a/third_party/rust/unicode-normalization/.cargo-checksum.json b/third_party/rust/unicode-normalization/.cargo-checksum.json
@@ -1 +0,0 @@
-{"files":{"COPYRIGHT":"23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d","Cargo.toml":"c9b3a7c693bc221578c150ca0f889cb42a301b09258a33d42d5a2541104534e3","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0","README.md":"5e6af58a3100ef18063422cb2fdf70afac62b5d60d828c6cde6344236d795be9","benches/bench.rs":"2c756c3a084c2ffc740988373fbc01a0333f7e85692ef547cac5ac592bed3024","scripts/unicode.py":"199ae07668c2f9c14b978cda56ab2d5deb0e4b819a3b7abba19bbfe10b1e49df","src/__test_api.rs":"4ca9e8f342dee364d0ca82f80504051b9d7c88fb6726bbe2683898ed0b919dfa","src/decompose.rs":"87bbc8e5814d79613804f1684f0f1fc572878ee31620f1857184509a6619f802","src/lib.rs":"ac4346617ee1f046a7d107ad50ecd928f96f5b1a25c45a1bc912a2d7b760c19f","src/lookups.rs":"962f9909b32e02b8a2a05836135d9cd39bb1ce01f7c659de99cbd8a3a3c78574","src/normalize.rs":"e6bb470ed410399f967b8eed63b161a93930520cf75f04a1d34b3d0aa458fbb6","src/perfect_hash.rs":"400c84e2f467f61bd55d55d08672da6a9ad7a57c938ce5d0c701a6994b1b273b","src/quick_check.rs":"eea209153e6d6b6ff242bc0df10678be2513a6440214bfdf1889321f9657d6d7","src/recompose.rs":"30746c36c1f2929a7b89f2771d63fc857b5d57a87934c661d82c5649ff0cf391","src/replace.rs":"33edf2301d3ec56fc12f48c9e60d6b23ada82c6ffa7e4230ceb744db3fa62ba1","src/stream_safe.rs":"5be52c38cf18f8dae33b84602c6e8c5785f531d598185bbdfac9b05696e60a2d","src/tables.rs":"69a0faad67afe03146d80ff5b2d889d1898cbfe8f7677a24f012148f6fd27348","src/test.rs":"8af1c74989355970cc150075f0c8517bb061caeb46a456458483fe5ef661dc89"},"package":"5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"}
-\ No newline at end of file
diff --git a/third_party/rust/unicode-normalization/COPYRIGHT b/third_party/rust/unicode-normalization/COPYRIGHT
@@ -1,7 +0,0 @@
-Licensed under the Apache License, Version 2.0
-<LICENSE-APACHE or
-http://www.apache.org/licenses/LICENSE-2.0> or the MIT
-license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
-at your option. All files in the project carrying such
-notice may not be copied, modified, or distributed except
-according to those terms.
diff --git a/third_party/rust/unicode-normalization/Cargo.toml b/third_party/rust/unicode-normalization/Cargo.toml
@@ -1,66 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2018"
-rust-version = "1.36"
-name = "unicode-normalization"
-version = "0.1.24"
-authors = [
-    "kwantam <kwantam@gmail.com>",
-    "Manish Goregaokar <manishsmail@gmail.com>",
-]
-build = false
-exclude = [
-    "target/*",
-    "Cargo.lock",
-    "scripts/tmp",
-    "*.txt",
-    "tests/*",
-]
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-description = """
-This crate provides functions for normalization of
-Unicode strings, including Canonical and Compatible
-Decomposition and Recomposition, as described in
-Unicode Standard Annex #15.
-"""
-homepage = "https://github.com/unicode-rs/unicode-normalization"
-documentation = "https://docs.rs/unicode-normalization/"
-readme = "README.md"
-keywords = [
-    "text",
-    "unicode",
-    "normalization",
-    "decomposition",
-    "recomposition",
-]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/unicode-rs/unicode-normalization"
-
-[lib]
-name = "unicode_normalization"
-path = "src/lib.rs"
-
-[[bench]]
-name = "bench"
-path = "benches/bench.rs"
-
-[dependencies.tinyvec]
-version = "1"
-features = ["alloc"]
-
-[features]
-default = ["std"]
-std = []
diff --git a/third_party/rust/unicode-normalization/LICENSE-APACHE b/third_party/rust/unicode-normalization/LICENSE-APACHE
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/third_party/rust/unicode-normalization/LICENSE-MIT b/third_party/rust/unicode-normalization/LICENSE-MIT
@@ -1,25 +0,0 @@
-Copyright (c) 2015 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/third_party/rust/unicode-normalization/README.md b/third_party/rust/unicode-normalization/README.md
@@ -1,39 +0,0 @@
-# unicode-normalization
-
-[![Build Status](https://travis-ci.org/unicode-rs/unicode-normalization.svg)](https://travis-ci.org/unicode-rs/unicode-normalization)
-[![Docs](https://docs.rs/unicode-normalization/badge.svg)](https://docs.rs/unicode-normalization/)
-
-Unicode character composition and decomposition utilities
-as described in
-[Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/).
-
-This crate requires Rust 1.36+.
-
-```rust
-extern crate unicode_normalization;
-
-use unicode_normalization::char::compose;
-use unicode_normalization::UnicodeNormalization;
-
-fn main() {
-    assert_eq!(compose('A','\u{30a}'), Some('Å'));
-
-    let s = "ÅΩ";
-    let c = s.nfc().collect::<String>();
-    assert_eq!(c, "ÅΩ");
-}
-```
-
-## crates.io
-
-You can use this package in your project by adding the following
-to your `Cargo.toml`:
-
-```toml
-[dependencies]
-unicode-normalization = "0.1.23"
-```
-
-## `no_std` + `alloc` support
-
-This crate is completely `no_std` + `alloc` compatible. This can be enabled by disabling the `std` feature, i.e. specifying `default-features = false` for this crate on your `Cargo.toml`.
diff --git a/third_party/rust/unicode-normalization/benches/bench.rs b/third_party/rust/unicode-normalization/benches/bench.rs
@@ -1,127 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate unicode_normalization;
-
-use std::fs;
-use test::Bencher;
-use unicode_normalization::UnicodeNormalization;
-
-const ASCII: &str = "all types of normalized";
-const NFC: &str = "Introducci\u{00f3}n a Unicode.pdf";
-const NFD: &str = "Introduccio\u{0301}n a Unicode.pdf";
-
-#[bench]
-fn bench_is_nfc_ascii(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfc(ASCII));
-}
-
-#[bench]
-fn bench_is_nfc_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfc(NFC));
-}
-
-#[bench]
-fn bench_is_nfc_not_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfc(NFD));
-}
-
-#[bench]
-fn bench_is_nfd_ascii(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfd(ASCII));
-}
-
-#[bench]
-fn bench_is_nfd_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfd(NFD));
-}
-
-#[bench]
-fn bench_is_nfd_not_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfd(NFC));
-}
-
-#[bench]
-fn bench_is_nfc_stream_safe_ascii(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfc_stream_safe(ASCII));
-}
-
-#[bench]
-fn bench_is_nfc_stream_safe_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfc_stream_safe(NFC));
-}
-
-#[bench]
-fn bench_is_nfc_stream_safe_not_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfc_stream_safe(NFD));
-}
-
-#[bench]
-fn bench_is_nfd_stream_safe_ascii(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfd_stream_safe(ASCII));
-}
-
-#[bench]
-fn bench_is_nfd_stream_safe_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfd_stream_safe(NFD));
-}
-
-#[bench]
-fn bench_is_nfd_stream_safe_not_normalized(b: &mut Bencher) {
-    b.iter(|| unicode_normalization::is_nfd_stream_safe(NFC));
-}
-
-#[bench]
-fn bench_nfc_ascii(b: &mut Bencher) {
-    b.iter(|| ASCII.nfc().count());
-}
-
-#[bench]
-fn bench_nfd_ascii(b: &mut Bencher) {
-    b.iter(|| ASCII.nfd().count());
-}
-
-#[bench]
-fn bench_nfc_long(b: &mut Bencher) {
-    let long = fs::read_to_string("benches/long.txt").unwrap();
-    b.iter(|| long.nfc().count());
-}
-
-#[bench]
-fn bench_nfd_long(b: &mut Bencher) {
-    let long = fs::read_to_string("benches/long.txt").unwrap();
-    b.iter(|| long.nfd().count());
-}
-
-#[bench]
-fn bench_nfkc_ascii(b: &mut Bencher) {
-    b.iter(|| ASCII.nfkc().count());
-}
-
-#[bench]
-fn bench_nfkd_ascii(b: &mut Bencher) {
-    b.iter(|| ASCII.nfkd().count());
-}
-
-#[bench]
-fn bench_nfkc_long(b: &mut Bencher) {
-    let long = fs::read_to_string("benches/long.txt").unwrap();
-    b.iter(|| long.nfkc().count());
-}
-
-#[bench]
-fn bench_nfkd_long(b: &mut Bencher) {
-    let long = fs::read_to_string("benches/long.txt").unwrap();
-    b.iter(|| long.nfkd().count());
-}
-
-#[bench]
-fn bench_streamsafe_ascii(b: &mut Bencher) {
-    b.iter(|| ASCII.stream_safe().count());
-}
-
-#[bench]
-fn bench_streamsafe_adversarial(b: &mut Bencher) {
-    let s = "bo\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}\u{032e}oom";
-    b.iter(|| s.stream_safe().count());
-}
diff --git a/third_party/rust/unicode-normalization/scripts/unicode.py b/third_party/rust/unicode-normalization/scripts/unicode.py
@@ -1,617 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2011-2018 The Rust Project Developers. See the COPYRIGHT
-# file at the top-level directory of this distribution and at
-# http://rust-lang.org/COPYRIGHT.
-#
-# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-# option. This file may not be copied, modified, or distributed
-# except according to those terms.
-
-# This script uses the following Unicode tables:
-# - DerivedNormalizationProps.txt
-# - NormalizationTest.txt
-# - UnicodeData.txt
-# - StandardizedVariants.txt
-#
-# Since this should not require frequent updates, we just store this
-# out-of-line and check the tables.rs and normalization_tests.rs files into git.
-import collections
-import urllib.request
-from itertools import batched
-
-UNICODE_VERSION = "16.0.0"
-UCD_URL = "https://www.unicode.org/Public/%s/ucd/" % UNICODE_VERSION
-
-PREAMBLE = """// Copyright 2012-2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
-
-#![allow(missing_docs)]
-"""
-
-NormalizationTest = collections.namedtuple(
-    "NormalizationTest",
-    ["source", "nfc", "nfd", "nfkc", "nfkd"],
-)
-
-# Mapping taken from Table 12 from:
-# http://www.unicode.org/reports/tr44/#General_Category_Values
-expanded_categories = {
-    'Lu': ['LC', 'L'], 'Ll': ['LC', 'L'], 'Lt': ['LC', 'L'],
-    'Lm': ['L'], 'Lo': ['L'],
-    'Mn': ['M'], 'Mc': ['M'], 'Me': ['M'],
-    'Nd': ['N'], 'Nl': ['N'], 'No': ['No'],
-    'Pc': ['P'], 'Pd': ['P'], 'Ps': ['P'], 'Pe': ['P'],
-    'Pi': ['P'], 'Pf': ['P'], 'Po': ['P'],
-    'Sm': ['S'], 'Sc': ['S'], 'Sk': ['S'], 'So': ['S'],
-    'Zs': ['Z'], 'Zl': ['Z'], 'Zp': ['Z'],
-    'Cc': ['C'], 'Cf': ['C'], 'Cs': ['C'], 'Co': ['C'], 'Cn': ['C'],
-}
-
-# Constants from Unicode 9.0.0 Section 3.12 Conjoining Jamo Behavior
-# http://www.unicode.org/versions/Unicode9.0.0/ch03.pdf#M9.32468.Heading.310.Combining.Jamo.Behavior
-S_BASE, L_COUNT, V_COUNT, T_COUNT = 0xAC00, 19, 21, 28
-S_COUNT = L_COUNT * V_COUNT * T_COUNT
-
-class UnicodeData(object):
-    def __init__(self):
-        self._load_unicode_data()
-        self.norm_props = self._load_norm_props()
-        self.norm_tests = self._load_norm_tests()
-
-        self.canon_comp = self._compute_canonical_comp()
-        self.canon_fully_decomp, self.compat_fully_decomp = self._compute_fully_decomposed()
-
-        self.cjk_compat_variants_fully_decomp = {}
-        self._load_cjk_compat_ideograph_variants()
-
-        def stats(name, table):
-            count = sum(len(v) for v in table.values())
-            print("%s: %d chars => %d decomposed chars" % (name, len(table), count))
-
-        print("Decomposition table stats:")
-        stats("Canonical decomp", self.canon_decomp)
-        stats("Compatible decomp", self.compat_decomp)
-        stats("Canonical fully decomp", self.canon_fully_decomp)
-        stats("Compatible fully decomp", self.compat_fully_decomp)
-        stats("CJK Compat Variants fully decomp", self.cjk_compat_variants_fully_decomp)
-
-        self.ss_leading, self.ss_trailing = self._compute_stream_safe_tables()
-
-    def _fetch(self, filename):
-        resp = urllib.request.urlopen(UCD_URL + filename)
-        return resp.read().decode('utf-8')
-
-    def _load_unicode_data(self):
-        self.name_to_char_int = {}
-        self.combining_classes = {}
-        self.compat_decomp = {}
-        self.canon_decomp = {}
-        self.general_category_mark = []
-        self.general_category_public_assigned = []
-
-        assigned_start = 0;
-        prev_char_int = -1;
-        prev_name = "";
-
-        for line in self._fetch("UnicodeData.txt").splitlines():
-            # See ftp://ftp.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.html
-            pieces = line.split(';')
-            assert len(pieces) == 15
-            char, name, category, cc, decomp = pieces[0], pieces[1], pieces[2], pieces[3], pieces[5]
-            char_int = int(char, 16)
-
-            name = pieces[1].strip()
-            self.name_to_char_int[name] = char_int
-
-            if cc != '0':
-                self.combining_classes[char_int] = cc
-
-            if decomp.startswith('<'):
-                self.compat_decomp[char_int] = [int(c, 16) for c in decomp.split()[1:]]
-            elif decomp != '':
-                self.canon_decomp[char_int] = [int(c, 16) for c in decomp.split()]
-
-            if category == 'M' or 'M' in expanded_categories.get(category, []):
-                self.general_category_mark.append(char_int)
-
-            assert category != 'Cn', "Unexpected: Unassigned codepoint in UnicodeData.txt"
-            if category not in ['Co', 'Cs']:
-                if char_int != prev_char_int + 1 and not is_first_and_last(prev_name, name):
-                    self.general_category_public_assigned.append((assigned_start, prev_char_int))
-                    assigned_start = char_int
-                prev_char_int = char_int
-                prev_name = name;
-
-        self.general_category_public_assigned.append((assigned_start, prev_char_int))
-
-    def _load_cjk_compat_ideograph_variants(self):
-        for line in self._fetch("StandardizedVariants.txt").splitlines():
-            strip_comments = line.split('#', 1)[0].strip()
-            if not strip_comments:
-                continue
-
-            variation_sequence, description, differences = strip_comments.split(';')
-            description = description.strip()
-
-            # Don't use variations that only apply in particular shaping environments.
-            if differences:
-                continue
-
-            # Look for entries where the description field is a codepoint name.
-            if description not in self.name_to_char_int:
-                continue
-
-            # Only consider the CJK Compatibility Ideographs.
-            if not description.startswith('CJK COMPATIBILITY IDEOGRAPH-'):
-                continue
-
-            char_int = self.name_to_char_int[description]
-
-            assert not char_int in self.combining_classes, "Unexpected: CJK compat variant with a combining class"
-            assert not char_int in self.compat_decomp, "Unexpected: CJK compat variant and compatibility decomposition"
-            assert len(self.canon_decomp[char_int]) == 1, "Unexpected: CJK compat variant and non-singleton canonical decomposition"
-            # If we ever need to handle Hangul here, we'll need to handle it separately.
-            assert not (S_BASE <= char_int < S_BASE + S_COUNT)
-
-            cjk_compat_variant_parts = [int(c, 16) for c in variation_sequence.split()]
-            for c in cjk_compat_variant_parts:
-                assert not c in self.canon_decomp, "Unexpected: CJK compat variant is unnormalized (canon)"
-                assert not c in self.compat_decomp, "Unexpected: CJK compat variant is unnormalized (compat)"
-            self.cjk_compat_variants_fully_decomp[char_int] = cjk_compat_variant_parts
-
-    def _load_norm_props(self):
-        props = collections.defaultdict(list)
-
-        for line in self._fetch("DerivedNormalizationProps.txt").splitlines():
-            (prop_data, _, _) = line.partition("#")
-            prop_pieces = prop_data.split(";")
-
-            if len(prop_pieces) < 2:
-                continue
-
-            assert len(prop_pieces) <= 3
-            (low, _, high) = prop_pieces[0].strip().partition("..")
-
-            prop = prop_pieces[1].strip()
-
-            data = None
-            if len(prop_pieces) == 3:
-                data = prop_pieces[2].strip()
-
-            props[prop].append((low, high, data))
-
-        return props
-
-    def _load_norm_tests(self):
-        tests = []
-        for line in self._fetch("NormalizationTest.txt").splitlines():
-            (test_data, _, _) = line.partition("#")
-            test_pieces = test_data.split(";")
-
-            if len(test_pieces) < 5:
-                continue
-
-            source, nfc, nfd, nfkc, nfkd = [[c.strip() for c in p.split()] for p in test_pieces[:5]]
-            tests.append(NormalizationTest(source, nfc, nfd, nfkc, nfkd))
-
-        return tests
-
-    def _compute_canonical_comp(self):
-        canon_comp = {}
-        comp_exclusions = [
-            (int(low, 16), int(high or low, 16))
-            for low, high, _ in self.norm_props["Full_Composition_Exclusion"]
-        ]
-        for char_int, decomp in self.canon_decomp.items():
-            if any(lo <= char_int <= hi for lo, hi in comp_exclusions):
-                continue
-
-            assert len(decomp) == 2
-            assert (decomp[0], decomp[1]) not in canon_comp
-            canon_comp[(decomp[0], decomp[1])] = char_int
-
-        return canon_comp
-
-    def _compute_fully_decomposed(self):
-        """
-        Even though the decomposition algorithm is recursive, it is possible
-        to precompute the recursion at table generation time with modest
-        increase to the table size.  Then, for these precomputed tables, we
-        note that 1) compatible decomposition is a subset of canonical
-        decomposition and 2) they mostly agree on their intersection.
-        Therefore, we don't store entries in the compatible table for
-        characters that decompose the same way under canonical decomposition.
-
-            Decomposition table stats:
-            Canonical decomp: 2060 chars => 3085 decomposed chars
-            Compatible decomp: 3662 chars => 5440 decomposed chars
-            Canonical fully decomp: 2060 chars => 3404 decomposed chars
-            Compatible fully decomp: 3678 chars => 5599 decomposed chars
-
-        The upshot is that decomposition code is very simple and easy to inline
-        at mild code size cost.
-        """
-        def _decompose(char_int, compatible):
-            # 7-bit ASCII never decomposes
-            if char_int <= 0x7f:
-                yield char_int
-                return
-
-            # Assert that we're handling Hangul separately.
-            assert not (S_BASE <= char_int < S_BASE + S_COUNT)
-
-            decomp = self.canon_decomp.get(char_int)
-            if decomp is not None:
-                for decomposed_ch in decomp:
-                    for fully_decomposed_ch in _decompose(decomposed_ch, compatible):
-                        yield fully_decomposed_ch
-                return
-
-            if compatible and char_int in self.compat_decomp:
-                for decomposed_ch in self.compat_decomp[char_int]:
-                    for fully_decomposed_ch in _decompose(decomposed_ch, compatible):
-                        yield fully_decomposed_ch
-                return
-
-            yield char_int
-            return
-
-        end_codepoint = max(
-            max(self.canon_decomp.keys()),
-            max(self.compat_decomp.keys()),
-        )
-
-        canon_fully_decomp = {}
-        compat_fully_decomp = {}
-
-        for char_int in range(0, end_codepoint + 1):
-            # Always skip Hangul, since it's more efficient to represent its
-            # decomposition programmatically.
-            if S_BASE <= char_int < S_BASE + S_COUNT:
-                continue
-
-            canon = list(_decompose(char_int, False))
-            if not (len(canon) == 1 and canon[0] == char_int):
-                canon_fully_decomp[char_int] = canon
-
-            compat = list(_decompose(char_int, True))
-            if not (len(compat) == 1 and compat[0] == char_int):
-                compat_fully_decomp[char_int] = compat
-
-        # Since canon_fully_decomp is a subset of compat_fully_decomp, we don't
-        # need to store their overlap when they agree.  When they don't agree,
-        # store the decomposition in the compatibility table since we'll check
-        # that first when normalizing to NFKD.
-        assert set(canon_fully_decomp) <= set(compat_fully_decomp)
-
-        for ch in set(canon_fully_decomp) & set(compat_fully_decomp):
-            if canon_fully_decomp[ch] == compat_fully_decomp[ch]:
-                del compat_fully_decomp[ch]
-
-        return canon_fully_decomp, compat_fully_decomp
-
-    def _compute_stream_safe_tables(self):
-        """
-        To make a text stream-safe with the Stream-Safe Text Process (UAX15-D4),
-        we need to be able to know the number of contiguous non-starters *after*
-        applying compatibility decomposition to each character.
-
-        We can do this incrementally by computing the number of leading and
-        trailing non-starters for each character's compatibility decomposition
-        with the following rules:
-
-        1) If a character is not affected by compatibility decomposition, look
-           up its canonical combining class to find out if it's a non-starter.
-        2) All Hangul characters are starters, even under decomposition.
-        3) Otherwise, very few decomposing characters have a nonzero count
-           of leading or trailing non-starters, so store these characters
-           with their associated counts in a separate table.
-        """
-        leading_nonstarters = {}
-        trailing_nonstarters = {}
-
-        for c in set(self.canon_fully_decomp) | set(self.compat_fully_decomp):
-            decomposed = self.compat_fully_decomp.get(c) or self.canon_fully_decomp[c]
-
-            num_leading = 0
-            for d in decomposed:
-                if d not in self.combining_classes:
-                    break
-                num_leading += 1
-
-            num_trailing = 0
-            for d in reversed(decomposed):
-                if d not in self.combining_classes:
-                    break
-                num_trailing += 1
-
-            if num_leading > 0:
-                leading_nonstarters[c] = num_leading
-            if num_trailing > 0:
-                trailing_nonstarters[c] = num_trailing
-
-        return leading_nonstarters, trailing_nonstarters
-
-hexify = lambda c: '{:04X}'.format(c)
-
-# Test whether `first` and `last` are corresponding "<..., First>" and
-# "<..., Last>" markers.
-def is_first_and_last(first, last):
-    if not first.startswith('<') or not first.endswith(', First>'):
-        return False
-    if not last.startswith('<') or not last.endswith(', Last>'):
-        return False
-    return first[1:-8] == last[1:-7]
-
-def gen_mph_data(name, d, kv_type, kv_callback, kv_row_width):
-    (salt, keys) = minimal_perfect_hash(d)
-    out.write(f"\npub(crate) const {name.upper()}_SALT: &[u16] = &[\n")
-    for s_row in batched(salt, 13):
-        out.write("   ")
-        for s in s_row:
-            out.write(f" 0x{s:03X},")
-        out.write("\n")
-    out.write("];\n")
-    out.write(f"pub(crate) const {name.upper()}_KV: &[{kv_type}] = &[\n")
-    for k_row in batched(keys, kv_row_width):
-        out.write("   ")
-        for k in k_row:
-            out.write(f" {kv_callback(k)},")
-        out.write("\n")
-    out.write("];\n")
-
-def gen_combining_class(combining_classes, out):
-    gen_mph_data('canonical_combining_class', combining_classes, 'u32',
-        lambda k: f"0x{int(combining_classes[k]) | (k << 8):07X}", 8)
-
-def gen_composition_table(canon_comp, out):
-    table = {}
-    for (c1, c2), c3 in canon_comp.items():
-        if c1 < 0x10000 and c2 < 0x10000:
-            table[(c1 << 16) | c2] = c3
-    (salt, keys) = minimal_perfect_hash(table)
-    gen_mph_data('COMPOSITION_TABLE', table, '(u32, char)',
-        lambda k: f"(0x{k:08X}, '\\u{{{table[k]:06X}}}')", 1)
-
-    out.write("pub(crate) fn composition_table_astral(c1: char, c2: char) -> Option<char> {\n")
-    out.write("    match (c1, c2) {\n")
-    for (c1, c2), c3 in sorted(canon_comp.items()):
-        if c1 >= 0x10000 or c2 >= 0x10000:
-            out.write("        ('\\u{%s}', '\\u{%s}') => Some('\\u{%s}'),\n" % (hexify(c1), hexify(c2), hexify(c3)))
-
-    out.write("        _ => None,\n")
-    out.write("    }\n")
-    out.write("}\n")
-
-def gen_decomposition_tables(canon_decomp, compat_decomp, cjk_compat_variants_decomp, out):
-    tables = [(canon_decomp, 'canonical'), (compat_decomp, 'compatibility'), (cjk_compat_variants_decomp, 'cjk_compat_variants')]
-    for table, name in tables:
-        offsets = {}
-        offset = 0
-        out.write("pub(crate) const %s_DECOMPOSED_CHARS: &[char] = &[\n" % name.upper())
-        for k, v in table.items():
-            offsets[k] = offset
-            offset += len(v)
-            for c in v:
-                out.write("    '\\u{%s}',\n" % hexify(c))
-        # The largest offset must fit in a u16.
-        assert offset < 65536
-        out.write("];\n")
-        gen_mph_data(name + '_decomposed', table, "(u32, (u16, u16))",
-            lambda k: f"(0x{k:05X}, (0x{offsets[k]:03X}, 0x{len(table[k]):X}))", 1)
-
-def gen_qc_match(prop_table, out):
-    out.write("    match c {\n")
-
-    for low, high, data in prop_table:
-        assert data in ('N', 'M')
-        result = "No" if data == 'N' else "Maybe"
-        if high:
-            out.write(r"        '\u{%s}'..='\u{%s}' => %s," % (low, high, result))
-        else:
-            out.write(r"        '\u{%s}' => %s," % (low, result))
-        out.write("\n")
-
-    out.write("        _ => Yes,\n")
-    out.write("    }\n")
-
-def gen_nfc_qc(prop_tables, out):
-    out.write("\n#[inline]\n")
-    out.write("#[allow(ellipsis_inclusive_range_patterns)]\n")
-    out.write("pub fn qc_nfc(c: char) -> IsNormalized {\n")
-    gen_qc_match(prop_tables['NFC_QC'], out)
-    out.write("}\n")
-
-def gen_nfkc_qc(prop_tables, out):
-    out.write("#[inline]\n")
-    out.write("#[allow(ellipsis_inclusive_range_patterns)]\n")
-    out.write("pub fn qc_nfkc(c: char) -> IsNormalized {\n")
-    gen_qc_match(prop_tables['NFKC_QC'], out)
-    out.write("}\n")
-
-def gen_nfd_qc(prop_tables, out):
-    out.write("#[inline]\n")
-    out.write("#[allow(ellipsis_inclusive_range_patterns)]\n")
-    out.write("pub fn qc_nfd(c: char) -> IsNormalized {\n")
-    gen_qc_match(prop_tables['NFD_QC'], out)
-    out.write("}\n")
-
-def gen_nfkd_qc(prop_tables, out):
-    out.write("#[inline]\n")
-    out.write("#[allow(ellipsis_inclusive_range_patterns)]\n")
-    out.write("pub fn qc_nfkd(c: char) -> IsNormalized {\n")
-    gen_qc_match(prop_tables['NFKD_QC'], out)
-    out.write("}\n")
-
-def gen_combining_mark(general_category_mark, out):
-    gen_mph_data('combining_mark', general_category_mark, 'u32',
-        lambda k: '0x{:05X}'.format(k), 10)
-
-def gen_public_assigned(general_category_public_assigned, out):
-    # This could be done as a hash but the table is somewhat small.
-    out.write("#[inline]\n")
-    out.write("pub fn is_public_assigned(c: char) -> bool {\n")
-    out.write("    match c {\n")
-
-    start = True
-    for first, last in general_category_public_assigned:
-        if start:
-            out.write("        ")
-            start = False
-        else:
-            out.write("\n        | ")
-        if first == last:
-            out.write("'\\u{%s}'" % hexify(first))
-        else:
-            out.write("'\\u{%s}'..='\\u{%s}'" % (hexify(first), hexify(last)))
-    out.write(" => true,\n")
-
-    out.write("        _ => false,\n")
-    out.write("    }\n")
-    out.write("}\n")
-
-def gen_stream_safe(leading, trailing, out):
-    # This could be done as a hash but the table is very small.
-    out.write("#[inline]\n")
-    out.write("pub fn stream_safe_leading_nonstarters(c: char) -> usize {\n")
-    out.write("    match c {\n")
-
-    for char, num_leading in sorted(leading.items()):
-        out.write("        '\\u{%s}' => %d,\n" % (hexify(char), num_leading))
-
-    out.write("        _ => 0,\n")
-    out.write("    }\n")
-    out.write("}\n")
-
-    gen_mph_data('trailing_nonstarters', trailing, 'u32',
-        lambda k: f"0x{int(trailing[k]) | (k << 8):07X}", 8)
-
-def gen_tests(tests, out):
-    out.write("""#[derive(Debug)]
-pub struct NormalizationTest {
-    pub source: &'static str,
-    pub nfc: &'static str,
-    pub nfd: &'static str,
-    pub nfkc: &'static str,
-    pub nfkd: &'static str,
-}
-
-""")
-
-    out.write("pub const NORMALIZATION_TESTS: &[NormalizationTest] = &[\n")
-    str_literal = lambda s: '"%s"' % "".join("\\u{%s}" % c for c in s)
-
-    for test in tests:
-        out.write("    NormalizationTest {\n")
-        out.write("        source: %s,\n" % str_literal(test.source))
-        out.write("        nfc: %s,\n" % str_literal(test.nfc))
-        out.write("        nfd: %s,\n" % str_literal(test.nfd))
-        out.write("        nfkc: %s,\n" % str_literal(test.nfkc))
-        out.write("        nfkd: %s,\n" % str_literal(test.nfkd))
-        out.write("    },\n")
-
-    out.write("];\n")
-
-# Guaranteed to be less than n.
-def my_hash(x, salt, n):
-    # This is hash based on the theory that multiplication is efficient
-    mask_32 = 0xffffffff
-    y = ((x + salt) * 2654435769) & mask_32
-    y ^= (x * 0x31415926) & mask_32
-    return (y * n) >> 32
-
-# Compute minimal perfect hash function, d can be either a dict or list of keys.
-def minimal_perfect_hash(d):
-    n = len(d)
-    buckets = dict((h, []) for h in range(n))
-    for key in d:
-        h = my_hash(key, 0, n)
-        buckets[h].append(key)
-    bsorted = [(len(buckets[h]), h) for h in range(n)]
-    bsorted.sort(reverse = True)
-    claimed = [False] * n
-    salts = [0] * n
-    keys = [0] * n
-    for (bucket_size, h) in bsorted:
-        # Note: the traditional perfect hashing approach would also special-case
-        # bucket_size == 1 here and assign any empty slot, rather than iterating
-        # until rehash finds an empty slot. But we're not doing that so we can
-        # avoid the branch.
-        if bucket_size == 0:
-            break
-        else:
-            for salt in range(1, 32768):
-                rehashes = [my_hash(key, salt, n) for key in buckets[h]]
-                # Make sure there are no rehash collisions within this bucket.
-                if all(not claimed[hash] for hash in rehashes):
-                    if len(set(rehashes)) < bucket_size:
-                        continue
-                    salts[h] = salt
-                    for key in buckets[h]:
-                        rehash = my_hash(key, salt, n)
-                        claimed[rehash] = True
-                        keys[rehash] = key
-                    break
-            if salts[h] == 0:
-                print("minimal perfect hashing failed")
-                # Note: if this happens (because of unfortunate data), then there are
-                # a few things that could be done. First, the hash function could be
-                # tweaked. Second, the bucket order could be scrambled (especially the
-                # singletons). Right now, the buckets are sorted, which has the advantage
-                # of being deterministic.
-                #
-                # As a more extreme approach, the singleton bucket optimization could be
-                # applied (give the direct address for singleton buckets, rather than
-                # relying on a rehash). That is definitely the more standard approach in
-                # the minimal perfect hashing literature, but in testing the branch was a
-                # significant slowdown.
-                exit(1)
-    return (salts, keys)
-
-if __name__ == '__main__':
-    data = UnicodeData()
-    with open("tables.rs", "w", newline = "\n") as out:
-        out.write(PREAMBLE)
-        out.write("use crate::quick_check::IsNormalized;\n")
-        out.write("use crate::quick_check::IsNormalized::*;\n")
-        out.write("\n")
-
-        version = "(%s, %s, %s)" % tuple(UNICODE_VERSION.split("."))
-        out.write("#[allow(unused)]\n")
-        out.write("pub const UNICODE_VERSION: (u8, u8, u8) = %s;\n" % version)
-
-        gen_combining_class(data.combining_classes, out)
-
-        gen_composition_table(data.canon_comp, out)
-
-        gen_decomposition_tables(data.canon_fully_decomp, data.compat_fully_decomp, data.cjk_compat_variants_fully_decomp, out)
-
-        gen_combining_mark(data.general_category_mark, out)
-
-        gen_public_assigned(data.general_category_public_assigned, out)
-
-        gen_nfc_qc(data.norm_props, out)
-
-        gen_nfkc_qc(data.norm_props, out)
-
-        gen_nfd_qc(data.norm_props, out)
-
-        gen_nfkd_qc(data.norm_props, out)
-
-        gen_stream_safe(data.ss_leading, data.ss_trailing, out)
-
-    with open("normalization_tests.rs", "w", newline = "\n") as out:
-        out.write(PREAMBLE)
-        gen_tests(data.norm_tests, out)
diff --git a/third_party/rust/unicode-normalization/src/__test_api.rs b/third_party/rust/unicode-normalization/src/__test_api.rs
@@ -1,18 +0,0 @@
-// This crate comprises hacks and glue required to test private functions from tests/
-//
-// Keep this as slim as possible.
-//
-// If you're caught using this outside this crates tests/, you get to clean up the mess.
-
-#[cfg(not(feature = "std"))]
-use alloc::string::String;
-
-use crate::stream_safe::StreamSafe;
-
-pub fn stream_safe(s: &str) -> String {
-    StreamSafe::new(s.chars()).collect()
-}
-
-pub mod quick_check {
-    pub use crate::quick_check::*;
-}
diff --git a/third_party/rust/unicode-normalization/src/decompose.rs b/third_party/rust/unicode-normalization/src/decompose.rs
@@ -1,173 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-use core::fmt::{self, Write};
-use core::iter::{Fuse, FusedIterator};
-use core::ops::Range;
-use tinyvec::TinyVec;
-
-#[derive(Clone)]
-enum DecompositionType {
-    Canonical,
-    Compatible,
-}
-
-/// External iterator for a string decomposition's characters.
-#[derive(Clone)]
-pub struct Decompositions<I> {
-    kind: DecompositionType,
-    iter: Fuse<I>,
-
-    // This buffer stores pairs of (canonical combining class, character),
-    // pushed onto the end in text order.
-    //
-    // It's divided into up to three sections:
-    // 1) A prefix that is free space;
-    // 2) "Ready" characters which are sorted and ready to emit on demand;
-    // 3) A "pending" block which stills needs more characters for us to be able
-    //    to sort in canonical order and is not safe to emit.
-    buffer: TinyVec<[(u8, char); 4]>,
-    ready: Range<usize>,
-}
-
-impl<I: Iterator<Item = char>> Decompositions<I> {
-    /// Create a new decomposition iterator for canonical decompositions (NFD)
-    ///
-    /// Note that this iterator can also be obtained by directly calling [`.nfd()`](crate::UnicodeNormalization::nfd)
-    /// on the iterator.
-    #[inline]
-    pub fn new_canonical(iter: I) -> Decompositions<I> {
-        Decompositions {
-            kind: self::DecompositionType::Canonical,
-            iter: iter.fuse(),
-            buffer: TinyVec::new(),
-            ready: 0..0,
-        }
-    }
-
-    /// Create a new decomposition iterator for compatability decompositions (NFkD)
-    ///
-    /// Note that this iterator can also be obtained by directly calling [`.nfd()`](crate::UnicodeNormalization::nfd)
-    /// on the iterator.
-    #[inline]
-    pub fn new_compatible(iter: I) -> Decompositions<I> {
-        Decompositions {
-            kind: self::DecompositionType::Compatible,
-            iter: iter.fuse(),
-            buffer: TinyVec::new(),
-            ready: 0..0,
-        }
-    }
-}
-
-impl<I> Decompositions<I> {
-    #[inline]
-    fn push_back(&mut self, ch: char) {
-        let class = super::char::canonical_combining_class(ch);
-
-        if class == 0 {
-            self.sort_pending();
-            self.buffer.push((class, ch));
-            self.ready.end = self.buffer.len();
-        } else {
-            self.buffer.push((class, ch));
-        }
-    }
-
-    #[inline]
-    fn sort_pending(&mut self) {
-        // NB: `sort_by_key` is stable, so it will preserve the original text's
-        // order within a combining class.
-        self.buffer[self.ready.end..].sort_by_key(|k| k.0);
-    }
-
-    #[inline]
-    fn reset_buffer(&mut self) {
-        // Equivalent to `self.buffer.drain(0..self.ready.end)`
-        // but faster than drain() if the buffer is a SmallVec or TinyVec
-        let pending = self.buffer.len() - self.ready.end;
-        for i in 0..pending {
-            self.buffer[i] = self.buffer[i + self.ready.end];
-        }
-        self.buffer.truncate(pending);
-        self.ready = 0..0;
-    }
-
-    #[inline]
-    fn increment_next_ready(&mut self) {
-        let next = self.ready.start + 1;
-        if next == self.ready.end {
-            self.reset_buffer();
-        } else {
-            self.ready.start = next;
-        }
-    }
-}
-
-impl<I: Iterator<Item = char>> Iterator for Decompositions<I> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        while self.ready.end == 0 {
-            match (self.iter.next(), &self.kind) {
-                (Some(ch), &DecompositionType::Canonical) => {
-                    super::char::decompose_canonical(ch, |d| self.push_back(d));
-                }
-                (Some(ch), &DecompositionType::Compatible) => {
-                    super::char::decompose_compatible(ch, |d| self.push_back(d));
-                }
-                (None, _) => {
-                    if self.buffer.is_empty() {
-                        return None;
-                    } else {
-                        self.sort_pending();
-                        self.ready.end = self.buffer.len();
-
-                        // This implementation means that we can call `next`
-                        // on an exhausted iterator; the last outer `next` call
-                        // will result in an inner `next` call. To make this
-                        // safe, we use `fuse`.
-                        break;
-                    }
-                }
-            }
-        }
-
-        // We can assume here that, if `self.ready.end` is greater than zero,
-        // it's also greater than `self.ready.start`. That's because we only
-        // increment `self.ready.start` inside `increment_next_ready`, and
-        // whenever it reaches equality with `self.ready.end`, we reset both
-        // to zero, maintaining the invariant that:
-        //      self.ready.start < self.ready.end || self.ready.end == self.ready.start == 0
-        //
-        // This less-than-obviously-safe implementation is chosen for performance,
-        // minimizing the number & complexity of branches in `next` in the common
-        // case of buffering then unbuffering a single character with each call.
-        let (_, ch) = self.buffer[self.ready.start];
-        self.increment_next_ready();
-        Some(ch)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (lower, _) = self.iter.size_hint();
-        (lower, None)
-    }
-}
-
-impl<I: Iterator<Item = char> + FusedIterator> FusedIterator for Decompositions<I> {}
-
-impl<I: Iterator<Item = char> + Clone> fmt::Display for Decompositions<I> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for c in self.clone() {
-            f.write_char(c)?;
-        }
-        Ok(())
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/lib.rs b/third_party/rust/unicode-normalization/src/lib.rs
@@ -1,227 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Unicode character composition and decomposition utilities
-//! as described in
-//! [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/).
-//!
-//! ```rust
-//! extern crate unicode_normalization;
-//!
-//! use unicode_normalization::char::compose;
-//! use unicode_normalization::UnicodeNormalization;
-//!
-//! fn main() {
-//!     assert_eq!(compose('A','\u{30a}'), Some('Å'));
-//!
-//!     let s = "ÅΩ";
-//!     let c = s.nfc().collect::<String>();
-//!     assert_eq!(c, "ÅΩ");
-//! }
-//! ```
-//!
-//! # crates.io
-//!
-//! You can use this package in your project by adding the following
-//! to your `Cargo.toml`:
-//!
-//! ```toml
-//! [dependencies]
-//! unicode-normalization = "0.1.20"
-//! ```
-
-#![deny(missing_docs, unsafe_code)]
-#![doc(
-    html_logo_url = "https://unicode-rs.github.io/unicode-rs_sm.png",
-    html_favicon_url = "https://unicode-rs.github.io/unicode-rs_sm.png"
-)]
-#![cfg_attr(not(feature = "std"), no_std)]
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-
-#[cfg(feature = "std")]
-extern crate core;
-
-extern crate tinyvec;
-
-pub use crate::decompose::Decompositions;
-pub use crate::quick_check::{
-    is_nfc, is_nfc_quick, is_nfc_stream_safe, is_nfc_stream_safe_quick, is_nfd, is_nfd_quick,
-    is_nfd_stream_safe, is_nfd_stream_safe_quick, is_nfkc, is_nfkc_quick, is_nfkd, is_nfkd_quick,
-    IsNormalized,
-};
-pub use crate::recompose::Recompositions;
-pub use crate::replace::Replacements;
-pub use crate::stream_safe::StreamSafe;
-pub use crate::tables::UNICODE_VERSION;
-use core::{option, str::Chars};
-
-mod decompose;
-mod lookups;
-mod normalize;
-mod perfect_hash;
-mod quick_check;
-mod recompose;
-mod replace;
-mod stream_safe;
-mod tables;
-
-#[doc(hidden)]
-pub mod __test_api;
-#[cfg(test)]
-mod test;
-
-/// Methods for composing and decomposing characters.
-pub mod char {
-    pub use crate::normalize::{
-        compose, decompose_canonical, decompose_cjk_compat_variants, decompose_compatible,
-    };
-
-    pub use crate::lookups::{canonical_combining_class, is_combining_mark};
-
-    /// Return whether the given character is assigned (`General_Category` != `Unassigned`)
-    /// and not Private-Use (`General_Category` != `Private_Use`), in the supported version
-    /// of Unicode.
-    pub use crate::tables::is_public_assigned;
-}
-
-/// Methods for iterating over strings while applying Unicode normalizations
-/// as described in
-/// [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/).
-pub trait UnicodeNormalization<I: Iterator<Item = char>> {
-    /// Returns an iterator over the string in Unicode Normalization Form D
-    /// (canonical decomposition).
-    fn nfd(self) -> Decompositions<I>;
-
-    /// Returns an iterator over the string in Unicode Normalization Form KD
-    /// (compatibility decomposition).
-    fn nfkd(self) -> Decompositions<I>;
-
-    /// An Iterator over the string in Unicode Normalization Form C
-    /// (canonical decomposition followed by canonical composition).
-    fn nfc(self) -> Recompositions<I>;
-
-    /// An Iterator over the string in Unicode Normalization Form KC
-    /// (compatibility decomposition followed by canonical composition).
-    fn nfkc(self) -> Recompositions<I>;
-
-    /// A transformation which replaces CJK Compatibility Ideograph codepoints
-    /// with normal forms using Standardized Variation Sequences. This is not
-    /// part of the canonical or compatibility decomposition algorithms, but
-    /// performing it before those algorithms produces normalized output which
-    /// better preserves the intent of the original text.
-    ///
-    /// Note that many systems today ignore variation selectors, so these
-    /// may not immediately help text display as intended, but they at
-    /// least preserve the information in a standardized form, giving
-    /// implementations the option to recognize them.
-    fn cjk_compat_variants(self) -> Replacements<I>;
-
-    /// An Iterator over the string with Conjoining Grapheme Joiner characters
-    /// inserted according to the Stream-Safe Text Process (UAX15-D4)
-    fn stream_safe(self) -> StreamSafe<I>;
-}
-
-impl<'a> UnicodeNormalization<Chars<'a>> for &'a str {
-    #[inline]
-    fn nfd(self) -> Decompositions<Chars<'a>> {
-        Decompositions::new_canonical(self.chars())
-    }
-
-    #[inline]
-    fn nfkd(self) -> Decompositions<Chars<'a>> {
-        Decompositions::new_compatible(self.chars())
-    }
-
-    #[inline]
-    fn nfc(self) -> Recompositions<Chars<'a>> {
-        Recompositions::new_canonical(self.chars())
-    }
-
-    #[inline]
-    fn nfkc(self) -> Recompositions<Chars<'a>> {
-        Recompositions::new_compatible(self.chars())
-    }
-
-    #[inline]
-    fn cjk_compat_variants(self) -> Replacements<Chars<'a>> {
-        replace::new_cjk_compat_variants(self.chars())
-    }
-
-    #[inline]
-    fn stream_safe(self) -> StreamSafe<Chars<'a>> {
-        StreamSafe::new(self.chars())
-    }
-}
-
-impl UnicodeNormalization<option::IntoIter<char>> for char {
-    #[inline]
-    fn nfd(self) -> Decompositions<option::IntoIter<char>> {
-        Decompositions::new_canonical(Some(self).into_iter())
-    }
-
-    #[inline]
-    fn nfkd(self) -> Decompositions<option::IntoIter<char>> {
-        Decompositions::new_compatible(Some(self).into_iter())
-    }
-
-    #[inline]
-    fn nfc(self) -> Recompositions<option::IntoIter<char>> {
-        Recompositions::new_canonical(Some(self).into_iter())
-    }
-
-    #[inline]
-    fn nfkc(self) -> Recompositions<option::IntoIter<char>> {
-        Recompositions::new_compatible(Some(self).into_iter())
-    }
-
-    #[inline]
-    fn cjk_compat_variants(self) -> Replacements<option::IntoIter<char>> {
-        replace::new_cjk_compat_variants(Some(self).into_iter())
-    }
-
-    #[inline]
-    fn stream_safe(self) -> StreamSafe<option::IntoIter<char>> {
-        StreamSafe::new(Some(self).into_iter())
-    }
-}
-
-impl<I: Iterator<Item = char>> UnicodeNormalization<I> for I {
-    #[inline]
-    fn nfd(self) -> Decompositions<I> {
-        Decompositions::new_canonical(self)
-    }
-
-    #[inline]
-    fn nfkd(self) -> Decompositions<I> {
-        Decompositions::new_compatible(self)
-    }
-
-    #[inline]
-    fn nfc(self) -> Recompositions<I> {
-        Recompositions::new_canonical(self)
-    }
-
-    #[inline]
-    fn nfkc(self) -> Recompositions<I> {
-        Recompositions::new_compatible(self)
-    }
-
-    #[inline]
-    fn cjk_compat_variants(self) -> Replacements<I> {
-        replace::new_cjk_compat_variants(self)
-    }
-
-    #[inline]
-    fn stream_safe(self) -> StreamSafe<I> {
-        StreamSafe::new(self)
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/lookups.rs b/third_party/rust/unicode-normalization/src/lookups.rs
@@ -1,138 +0,0 @@
-// Copyright 2019 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Lookups of unicode properties using minimal perfect hashing.
-
-use crate::perfect_hash::mph_lookup;
-use crate::tables::*;
-
-/// Look up the canonical combining class for a codepoint.
-///
-/// The value returned is as defined in the Unicode Character Database.
-pub fn canonical_combining_class(c: char) -> u8 {
-    mph_lookup(
-        c.into(),
-        CANONICAL_COMBINING_CLASS_SALT,
-        CANONICAL_COMBINING_CLASS_KV,
-        u8_lookup_fk,
-        u8_lookup_fv,
-        0,
-    )
-}
-
-pub(crate) fn composition_table(c1: char, c2: char) -> Option<char> {
-    if c1 < '\u{10000}' && c2 < '\u{10000}' {
-        mph_lookup(
-            (c1 as u32) << 16 | (c2 as u32),
-            COMPOSITION_TABLE_SALT,
-            COMPOSITION_TABLE_KV,
-            pair_lookup_fk,
-            pair_lookup_fv_opt,
-            None,
-        )
-    } else {
-        composition_table_astral(c1, c2)
-    }
-}
-
-pub(crate) fn canonical_fully_decomposed(c: char) -> Option<&'static [char]> {
-    mph_lookup(
-        c.into(),
-        CANONICAL_DECOMPOSED_SALT,
-        CANONICAL_DECOMPOSED_KV,
-        pair_lookup_fk,
-        pair_lookup_fv_opt,
-        None,
-    )
-    .map(|(start, len)| &CANONICAL_DECOMPOSED_CHARS[start as usize..][..len as usize])
-}
-
-pub(crate) fn compatibility_fully_decomposed(c: char) -> Option<&'static [char]> {
-    mph_lookup(
-        c.into(),
-        COMPATIBILITY_DECOMPOSED_SALT,
-        COMPATIBILITY_DECOMPOSED_KV,
-        pair_lookup_fk,
-        pair_lookup_fv_opt,
-        None,
-    )
-    .map(|(start, len)| &COMPATIBILITY_DECOMPOSED_CHARS[start as usize..][..len as usize])
-}
-
-pub(crate) fn cjk_compat_variants_fully_decomposed(c: char) -> Option<&'static [char]> {
-    mph_lookup(
-        c.into(),
-        CJK_COMPAT_VARIANTS_DECOMPOSED_SALT,
-        CJK_COMPAT_VARIANTS_DECOMPOSED_KV,
-        pair_lookup_fk,
-        pair_lookup_fv_opt,
-        None,
-    )
-    .map(|(start, len)| &CJK_COMPAT_VARIANTS_DECOMPOSED_CHARS[start as usize..][..len as usize])
-}
-
-/// Return whether the given character is a combining mark (`General_Category=Mark`)
-pub fn is_combining_mark(c: char) -> bool {
-    mph_lookup(
-        c.into(),
-        COMBINING_MARK_SALT,
-        COMBINING_MARK_KV,
-        bool_lookup_fk,
-        bool_lookup_fv,
-        false,
-    )
-}
-
-pub fn stream_safe_trailing_nonstarters(c: char) -> usize {
-    mph_lookup(
-        c.into(),
-        TRAILING_NONSTARTERS_SALT,
-        TRAILING_NONSTARTERS_KV,
-        u8_lookup_fk,
-        u8_lookup_fv,
-        0,
-    ) as usize
-}
-
-/// Extract the key in a 24 bit key and 8 bit value packed in a u32.
-#[inline]
-fn u8_lookup_fk(kv: u32) -> u32 {
-    kv >> 8
-}
-
-/// Extract the value in a 24 bit key and 8 bit value packed in a u32.
-#[inline]
-fn u8_lookup_fv(kv: u32) -> u8 {
-    (kv & 0xff) as u8
-}
-
-/// Extract the key for a boolean lookup.
-#[inline]
-fn bool_lookup_fk(kv: u32) -> u32 {
-    kv
-}
-
-/// Extract the value for a boolean lookup.
-#[inline]
-fn bool_lookup_fv(_kv: u32) -> bool {
-    true
-}
-
-/// Extract the key in a pair.
-#[inline]
-fn pair_lookup_fk<T>(kv: (u32, T)) -> u32 {
-    kv.0
-}
-
-/// Extract the value in a pair, returning an option.
-#[inline]
-fn pair_lookup_fv_opt<T>(kv: (u32, T)) -> Option<T> {
-    Some(kv.1)
-}
diff --git a/third_party/rust/unicode-normalization/src/normalize.rs b/third_party/rust/unicode-normalization/src/normalize.rs
@@ -1,224 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Functions for computing canonical and compatible decompositions for Unicode characters.
-use crate::lookups::{
-    canonical_fully_decomposed, cjk_compat_variants_fully_decomposed,
-    compatibility_fully_decomposed, composition_table,
-};
-
-use core::char;
-
-/// Compute canonical Unicode decomposition for character.
-/// See [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/)
-/// for more information.
-#[inline]
-pub fn decompose_canonical<F>(c: char, emit_char: F)
-where
-    F: FnMut(char),
-{
-    decompose(c, canonical_fully_decomposed, emit_char)
-}
-
-/// Compute canonical or compatible Unicode decomposition for character.
-/// See [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/)
-/// for more information.
-#[inline]
-pub fn decompose_compatible<F: FnMut(char)>(c: char, emit_char: F) {
-    let decompose_char =
-        |c| compatibility_fully_decomposed(c).or_else(|| canonical_fully_decomposed(c));
-    decompose(c, decompose_char, emit_char)
-}
-
-/// Compute standard-variation decomposition for character.
-///
-/// [Standardized Variation Sequences] are used instead of the standard canonical
-/// decompositions, notably for CJK codepoints with singleton canonical decompositions,
-/// to avoid losing information. See the
-/// [Unicode Variation Sequence FAQ](http://unicode.org/faq/vs.html) and the
-/// "Other Enhancements" section of the
-/// [Unicode 6.3 Release Summary](https://www.unicode.org/versions/Unicode6.3.0/#Summary)
-/// for more information.
-#[inline]
-pub fn decompose_cjk_compat_variants<F>(c: char, mut emit_char: F)
-where
-    F: FnMut(char),
-{
-    // 7-bit ASCII never decomposes
-    if c <= '\x7f' {
-        emit_char(c);
-        return;
-    }
-
-    // Don't perform decomposition for Hangul
-
-    if let Some(decomposed) = cjk_compat_variants_fully_decomposed(c) {
-        for &d in decomposed {
-            emit_char(d);
-        }
-        return;
-    }
-
-    // Finally bottom out.
-    emit_char(c);
-}
-
-#[inline]
-#[allow(unsafe_code)]
-fn decompose<D, F>(c: char, decompose_char: D, mut emit_char: F)
-where
-    D: Fn(char) -> Option<&'static [char]>,
-    F: FnMut(char),
-{
-    // 7-bit ASCII never decomposes
-    if c <= '\x7f' {
-        emit_char(c);
-        return;
-    }
-
-    // Perform decomposition for Hangul
-    if is_hangul_syllable(c) {
-        // Safety: Hangul Syllables invariant checked by is_hangul_syllable above
-        unsafe {
-            decompose_hangul(c, emit_char);
-        }
-        return;
-    }
-
-    if let Some(decomposed) = decompose_char(c) {
-        for &d in decomposed {
-            emit_char(d);
-        }
-        return;
-    }
-
-    // Finally bottom out.
-    emit_char(c);
-}
-
-/// Compose two characters into a single character, if possible.
-/// See [Unicode Standard Annex #15](http://www.unicode.org/reports/tr15/)
-/// for more information.
-pub fn compose(a: char, b: char) -> Option<char> {
-    compose_hangul(a, b).or_else(|| composition_table(a, b))
-}
-
-// Constants from Unicode 9.0.0 Section 3.12 Conjoining Jamo Behavior
-// http://www.unicode.org/versions/Unicode9.0.0/ch03.pdf#M9.32468.Heading.310.Combining.Jamo.Behavior
-const S_BASE: u32 = 0xAC00;
-const L_BASE: u32 = 0x1100;
-const V_BASE: u32 = 0x1161;
-const T_BASE: u32 = 0x11A7;
-const L_COUNT: u32 = 19;
-const V_COUNT: u32 = 21;
-const T_COUNT: u32 = 28;
-const N_COUNT: u32 = V_COUNT * T_COUNT;
-const S_COUNT: u32 = L_COUNT * N_COUNT;
-
-const S_LAST: u32 = S_BASE + S_COUNT - 1;
-const L_LAST: u32 = L_BASE + L_COUNT - 1;
-const V_LAST: u32 = V_BASE + V_COUNT - 1;
-const T_LAST: u32 = T_BASE + T_COUNT - 1;
-
-// Composition only occurs for `TPart`s in `U+11A8 ..= U+11C2`,
-// i.e. `T_BASE + 1 ..= T_LAST`.
-const T_FIRST: u32 = T_BASE + 1;
-
-// Safety-usable invariant: This ensures that c is a valid Hangul Syllable character (U+AC00..U+D7AF)
-pub(crate) fn is_hangul_syllable(c: char) -> bool {
-    // Safety: This checks the range 0xAC00 (S_BASE) to 0xD7A4 (S_BASE + S_COUNT), upholding the safety-usable invariant
-    (c as u32) >= S_BASE && (c as u32) < (S_BASE + S_COUNT)
-}
-
-// Decompose a precomposed Hangul syllable
-// Safety: `s` MUST be a valid Hangul Syllable character, between U+AC00..U+D7AF
-#[allow(unsafe_code, unused_unsafe)]
-#[inline(always)]
-unsafe fn decompose_hangul<F>(s: char, mut emit_char: F)
-where
-    F: FnMut(char),
-{
-    // This will be at most 0x2baf, the size of the Hangul Syllables block
-    let s_index = s as u32 - S_BASE;
-    // This will be at most 0x2baf / (21 * 28), 19
-    let l_index = s_index / N_COUNT;
-    unsafe {
-        // Safety: L_BASE (0x1100) plus at most 19 is still going to be in range for a valid Unicode code point in the BMP (< 0xD800)
-        emit_char(char::from_u32_unchecked(L_BASE + l_index));
-
-        // Safety: This will be at most (N_COUNT - 1) / T_COUNT = (V*T - 1) / T, which gives us an upper bound of V_COUNT = 21
-        let v_index = (s_index % N_COUNT) / T_COUNT;
-        // Safety: V_BASE (0x1161) plus at most 21 is still going to be in range for a valid Unicode code point in the BMP (< 0xD800)
-        emit_char(char::from_u32_unchecked(V_BASE + v_index));
-
-        // Safety: This will be at most T_COUNT - 1 (27)
-        let t_index = s_index % T_COUNT;
-        if t_index > 0 {
-            // Safety: T_BASE (0x11A7) plus at most 27 is still going to be in range for a valid Unicode code point in the BMP (< 0xD800)
-            emit_char(char::from_u32_unchecked(T_BASE + t_index));
-        }
-    }
-}
-
-#[inline]
-pub(crate) fn hangul_decomposition_length(s: char) -> usize {
-    let si = s as u32 - S_BASE;
-    let ti = si % T_COUNT;
-    if ti > 0 {
-        3
-    } else {
-        2
-    }
-}
-
-// Compose a pair of Hangul Jamo
-#[allow(unsafe_code)]
-#[inline(always)]
-#[allow(ellipsis_inclusive_range_patterns)]
-fn compose_hangul(a: char, b: char) -> Option<char> {
-    let (a, b) = (a as u32, b as u32);
-    match (a, b) {
-        // Compose a leading consonant and a vowel together into an LV_Syllable
-        (L_BASE..=L_LAST, V_BASE..=V_LAST) => {
-            // Safety: based on the above bounds, l_index will be less than or equal to L_COUNT (19)
-            // and v_index will be <= V_COUNT (21)
-            let l_index = a - L_BASE;
-            let v_index = b - V_BASE;
-            // Safety: This will be <= 19 * (20 * 21) + (21 * 20), which is 8400.
-            let lv_index = l_index * N_COUNT + v_index * T_COUNT;
-            // Safety: This is between 0xAC00 and 0xCCD0, which are in range for Hangul Syllables (U+AC00..U+D7AF) and also in range
-            // for BMP unicode
-            let s = S_BASE + lv_index;
-            // Safety: We've verified this is in-range
-            Some(unsafe { char::from_u32_unchecked(s) })
-        }
-        // Compose an LV_Syllable and a trailing consonant into an LVT_Syllable
-        (S_BASE..=S_LAST, T_FIRST..=T_LAST) if (a - S_BASE) % T_COUNT == 0 => {
-            // Safety: a is between 0xAC00 and (0xAC00 + 19 * 21 * 28). b - T_BASE is between 0 and 19.
-            // Adding a number 0 to 19 to a number that is at largest 0xD7A4 will not go out of bounds to 0xD800 (where the
-            // surrogates start), so this is safe.
-            Some(unsafe { char::from_u32_unchecked(a + (b - T_BASE)) })
-        }
-        _ => None,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::compose_hangul;
-
-    // Regression test from a bugfix where we were composing an LV_Syllable with
-    // T_BASE directly. (We should only compose an LV_Syllable with a character
-    // in the range `T_BASE + 1 ..= T_LAST`.)
-    #[test]
-    fn test_hangul_composition() {
-        assert_eq!(compose_hangul('\u{c8e0}', '\u{11a7}'), None);
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/perfect_hash.rs b/third_party/rust/unicode-normalization/src/perfect_hash.rs
@@ -1,50 +0,0 @@
-// Copyright 2019 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support for lookups based on minimal perfect hashing.
-
-// This function is based on multiplication being fast and is "good enough". Also
-// it can share some work between the unsalted and salted versions.
-#[inline]
-fn my_hash(key: u32, salt: u32, n: usize) -> usize {
-    let y = key.wrapping_add(salt).wrapping_mul(2654435769);
-    let y = y ^ key.wrapping_mul(0x31415926);
-    (((y as u64) * (n as u64)) >> 32) as usize
-}
-
-/// Do a lookup using minimal perfect hashing.
-///
-/// The table is stored as a sequence of "salt" values, then a sequence of
-/// values that contain packed key/value pairs. The strategy is to hash twice.
-/// The first hash retrieves a salt value that makes the second hash unique.
-/// The hash function doesn't have to be very good, just good enough that the
-/// resulting map is unique.
-#[inline]
-pub(crate) fn mph_lookup<KV, V, FK, FV>(
-    x: u32,
-    salt: &[u16],
-    kv: &[KV],
-    fk: FK,
-    fv: FV,
-    default: V,
-) -> V
-where
-    KV: Copy,
-    FK: Fn(KV) -> u32,
-    FV: Fn(KV) -> V,
-{
-    let s = salt[my_hash(x, 0, salt.len())] as u32;
-    let key_val = kv[my_hash(x, s, salt.len())];
-    if x == fk(key_val) {
-        fv(key_val)
-    } else {
-        default
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/quick_check.rs b/third_party/rust/unicode-normalization/src/quick_check.rs
@@ -1,190 +0,0 @@
-use crate::lookups::canonical_combining_class;
-use crate::stream_safe;
-use crate::tables;
-use crate::UnicodeNormalization;
-
-/// QuickCheck quickly determines if a string is normalized, it can return
-/// `Maybe`
-///
-/// The QuickCheck algorithm can quickly determine if a text is or isn't
-/// normalized without any allocations in many cases, but it has to be able to
-/// return `Maybe` when a full decomposition and recomposition is necessary.
-#[derive(Debug, Eq, PartialEq)]
-pub enum IsNormalized {
-    /// The text is definitely normalized.
-    Yes,
-    /// The text is definitely not normalized.
-    No,
-    /// The text may be normalized.
-    Maybe,
-}
-
-// https://unicode.org/reports/tr15/#Detecting_Normalization_Forms
-#[inline]
-fn quick_check<F, I>(s: I, is_allowed: F, stream_safe: bool) -> IsNormalized
-where
-    I: Iterator<Item = char>,
-    F: Fn(char) -> IsNormalized,
-{
-    let mut last_cc = 0u8;
-    let mut nonstarter_count = 0;
-    let mut result = IsNormalized::Yes;
-    for ch in s {
-        // For ASCII we know it's always allowed and a starter
-        if ch <= '\x7f' {
-            last_cc = 0;
-            nonstarter_count = 0;
-            continue;
-        }
-
-        // Otherwise, lookup the combining class and QC property
-        let cc = canonical_combining_class(ch);
-        if last_cc > cc && cc != 0 {
-            return IsNormalized::No;
-        }
-        match is_allowed(ch) {
-            IsNormalized::Yes => (),
-            IsNormalized::No => return IsNormalized::No,
-            IsNormalized::Maybe => {
-                result = IsNormalized::Maybe;
-            }
-        }
-        if stream_safe {
-            let decomp = stream_safe::classify_nonstarters(ch);
-
-            // If we're above `MAX_NONSTARTERS`, we're definitely *not*
-            // stream-safe normalized.
-            if nonstarter_count + decomp.leading_nonstarters > stream_safe::MAX_NONSTARTERS {
-                return IsNormalized::No;
-            }
-            if decomp.leading_nonstarters == decomp.decomposition_len {
-                nonstarter_count += decomp.decomposition_len;
-            } else {
-                nonstarter_count = decomp.trailing_nonstarters;
-            }
-        }
-        last_cc = cc;
-    }
-    result
-}
-
-/// Quickly check if a string is in NFC, potentially returning
-/// `IsNormalized::Maybe` if further checks are necessary.  In this case a check
-/// like `s.chars().nfc().eq(s.chars())` should suffice.
-#[inline]
-pub fn is_nfc_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
-    quick_check(s, tables::qc_nfc, false)
-}
-
-/// Quickly check if a string is in NFKC.
-#[inline]
-pub fn is_nfkc_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
-    quick_check(s, tables::qc_nfkc, false)
-}
-
-/// Quickly check if a string is in NFD.
-#[inline]
-pub fn is_nfd_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
-    quick_check(s, tables::qc_nfd, false)
-}
-
-/// Quickly check if a string is in NFKD.
-#[inline]
-pub fn is_nfkd_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
-    quick_check(s, tables::qc_nfkd, false)
-}
-
-/// Quickly check if a string is Stream-Safe NFC.
-#[inline]
-pub fn is_nfc_stream_safe_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
-    quick_check(s, tables::qc_nfc, true)
-}
-
-/// Quickly check if a string is Stream-Safe NFD.
-#[inline]
-pub fn is_nfd_stream_safe_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
-    quick_check(s, tables::qc_nfd, true)
-}
-
-/// Authoritatively check if a string is in NFC.
-#[inline]
-pub fn is_nfc(s: &str) -> bool {
-    match is_nfc_quick(s.chars()) {
-        IsNormalized::Yes => true,
-        IsNormalized::No => false,
-        IsNormalized::Maybe => s.chars().eq(s.chars().nfc()),
-    }
-}
-
-/// Authoritatively check if a string is in NFKC.
-#[inline]
-pub fn is_nfkc(s: &str) -> bool {
-    match is_nfkc_quick(s.chars()) {
-        IsNormalized::Yes => true,
-        IsNormalized::No => false,
-        IsNormalized::Maybe => s.chars().eq(s.chars().nfkc()),
-    }
-}
-
-/// Authoritatively check if a string is in NFD.
-#[inline]
-pub fn is_nfd(s: &str) -> bool {
-    match is_nfd_quick(s.chars()) {
-        IsNormalized::Yes => true,
-        IsNormalized::No => false,
-        IsNormalized::Maybe => s.chars().eq(s.chars().nfd()),
-    }
-}
-
-/// Authoritatively check if a string is in NFKD.
-#[inline]
-pub fn is_nfkd(s: &str) -> bool {
-    match is_nfkd_quick(s.chars()) {
-        IsNormalized::Yes => true,
-        IsNormalized::No => false,
-        IsNormalized::Maybe => s.chars().eq(s.chars().nfkd()),
-    }
-}
-
-/// Authoritatively check if a string is Stream-Safe NFC.
-#[inline]
-pub fn is_nfc_stream_safe(s: &str) -> bool {
-    match is_nfc_stream_safe_quick(s.chars()) {
-        IsNormalized::Yes => true,
-        IsNormalized::No => false,
-        IsNormalized::Maybe => s.chars().eq(s.chars().stream_safe().nfc()),
-    }
-}
-
-/// Authoritatively check if a string is Stream-Safe NFD.
-#[inline]
-pub fn is_nfd_stream_safe(s: &str) -> bool {
-    match is_nfd_stream_safe_quick(s.chars()) {
-        IsNormalized::Yes => true,
-        IsNormalized::No => false,
-        IsNormalized::Maybe => s.chars().eq(s.chars().stream_safe().nfd()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{is_nfc_stream_safe_quick, is_nfd_stream_safe_quick, IsNormalized};
-
-    #[test]
-    fn test_stream_safe_nfd() {
-        let okay = "Da\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}ngerzone";
-        assert_eq!(is_nfd_stream_safe_quick(okay.chars()), IsNormalized::Yes);
-
-        let too_much = "Da\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{031e}\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}ngerzone";
-        assert_eq!(is_nfd_stream_safe_quick(too_much.chars()), IsNormalized::No);
-    }
-
-    #[test]
-    fn test_stream_safe_nfc() {
-        let okay = "ok\u{e0}\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}y";
-        assert_eq!(is_nfc_stream_safe_quick(okay.chars()), IsNormalized::Maybe);
-
-        let too_much = "not ok\u{e0}\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{031e}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}y";
-        assert_eq!(is_nfc_stream_safe_quick(too_much.chars()), IsNormalized::No);
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/recompose.rs b/third_party/rust/unicode-normalization/src/recompose.rs
@@ -1,169 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use crate::decompose::Decompositions;
-use core::{
-    fmt::{self, Write},
-    iter::FusedIterator,
-};
-use tinyvec::TinyVec;
-
-#[derive(Clone)]
-enum RecompositionState {
-    Composing,
-    Purging(usize),
-    Finished(usize),
-}
-
-/// External iterator for a string recomposition's characters.
-#[derive(Clone)]
-pub struct Recompositions<I> {
-    iter: Decompositions<I>,
-    state: RecompositionState,
-    buffer: TinyVec<[char; 4]>,
-    composee: Option<char>,
-    last_ccc: Option<u8>,
-}
-
-impl<I: Iterator<Item = char>> Recompositions<I> {
-    /// Create a new recomposition iterator for canonical compositions (NFC)
-    ///
-    /// Note that this iterator can also be obtained by directly calling [`.nfc()`](crate::UnicodeNormalization::nfc)
-    /// on the iterator.
-    #[inline]
-    pub fn new_canonical(iter: I) -> Self {
-        Recompositions {
-            iter: Decompositions::new_canonical(iter),
-            state: self::RecompositionState::Composing,
-            buffer: TinyVec::new(),
-            composee: None,
-            last_ccc: None,
-        }
-    }
-
-    /// Create a new recomposition iterator for compatability compositions (NFkC)
-    ///
-    /// Note that this iterator can also be obtained by directly calling [`.nfkc()`](crate::UnicodeNormalization::nfkc)
-    /// on the iterator.
-    #[inline]
-    pub fn new_compatible(iter: I) -> Self {
-        Recompositions {
-            iter: Decompositions::new_compatible(iter),
-            state: self::RecompositionState::Composing,
-            buffer: TinyVec::new(),
-            composee: None,
-            last_ccc: None,
-        }
-    }
-}
-
-impl<I: Iterator<Item = char>> Iterator for Recompositions<I> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        use self::RecompositionState::*;
-
-        loop {
-            match self.state {
-                Composing => {
-                    for ch in self.iter.by_ref() {
-                        let ch_class = super::char::canonical_combining_class(ch);
-                        let k = match self.composee {
-                            None => {
-                                if ch_class != 0 {
-                                    return Some(ch);
-                                }
-                                self.composee = Some(ch);
-                                continue;
-                            }
-                            Some(k) => k,
-                        };
-                        match self.last_ccc {
-                            None => match super::char::compose(k, ch) {
-                                Some(r) => {
-                                    self.composee = Some(r);
-                                    continue;
-                                }
-                                None => {
-                                    if ch_class == 0 {
-                                        self.composee = Some(ch);
-                                        return Some(k);
-                                    }
-                                    self.buffer.push(ch);
-                                    self.last_ccc = Some(ch_class);
-                                }
-                            },
-                            Some(l_class) => {
-                                if l_class >= ch_class {
-                                    // `ch` is blocked from `composee`
-                                    if ch_class == 0 {
-                                        self.composee = Some(ch);
-                                        self.last_ccc = None;
-                                        self.state = Purging(0);
-                                        return Some(k);
-                                    }
-                                    self.buffer.push(ch);
-                                    self.last_ccc = Some(ch_class);
-                                    continue;
-                                }
-                                match super::char::compose(k, ch) {
-                                    Some(r) => {
-                                        self.composee = Some(r);
-                                        continue;
-                                    }
-                                    None => {
-                                        self.buffer.push(ch);
-                                        self.last_ccc = Some(ch_class);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    self.state = Finished(0);
-                    if self.composee.is_some() {
-                        return self.composee.take();
-                    }
-                }
-                Purging(next) => match self.buffer.get(next).cloned() {
-                    None => {
-                        self.buffer.clear();
-                        self.state = Composing;
-                    }
-                    s => {
-                        self.state = Purging(next + 1);
-                        return s;
-                    }
-                },
-                Finished(next) => match self.buffer.get(next).cloned() {
-                    None => {
-                        self.buffer.clear();
-                        return self.composee.take();
-                    }
-                    s => {
-                        self.state = Finished(next + 1);
-                        return s;
-                    }
-                },
-            }
-        }
-    }
-}
-
-impl<I: Iterator<Item = char> + FusedIterator> FusedIterator for Recompositions<I> {}
-
-impl<I: Iterator<Item = char> + Clone> fmt::Display for Recompositions<I> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for c in self.clone() {
-            f.write_char(c)?;
-        }
-        Ok(())
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/replace.rs b/third_party/rust/unicode-normalization/src/replace.rs
@@ -1,66 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-use core::{
-    fmt::{self, Write},
-    iter::FusedIterator,
-};
-use tinyvec::ArrayVec;
-
-/// External iterator for replacements for a string's characters.
-#[derive(Clone)]
-pub struct Replacements<I> {
-    iter: I,
-    // At this time, the longest replacement sequence has length 2, so we just
-    // need buffer space for 1 codepoint.
-    buffer: Option<char>,
-}
-
-#[inline]
-pub fn new_cjk_compat_variants<I: Iterator<Item = char>>(iter: I) -> Replacements<I> {
-    Replacements { iter, buffer: None }
-}
-
-impl<I: Iterator<Item = char>> Iterator for Replacements<I> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        if let Some(c) = self.buffer.take() {
-            return Some(c);
-        }
-
-        match self.iter.next() {
-            Some(ch) => {
-                // At this time, the longest replacement sequence has length 2.
-                let mut buffer = ArrayVec::<[char; 2]>::new();
-                super::char::decompose_cjk_compat_variants(ch, |d| buffer.push(d));
-                self.buffer = buffer.get(1).copied();
-                Some(buffer[0])
-            }
-            None => None,
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (lower, _) = self.iter.size_hint();
-        (lower, None)
-    }
-}
-
-impl<I: Iterator<Item = char> + FusedIterator> FusedIterator for Replacements<I> {}
-
-impl<I: Iterator<Item = char> + Clone> fmt::Display for Replacements<I> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for c in self.clone() {
-            f.write_char(c)?;
-        }
-        Ok(())
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/stream_safe.rs b/third_party/rust/unicode-normalization/src/stream_safe.rs
@@ -1,174 +0,0 @@
-use core::iter::FusedIterator;
-
-use crate::lookups::{
-    canonical_combining_class, canonical_fully_decomposed, compatibility_fully_decomposed,
-    stream_safe_trailing_nonstarters,
-};
-use crate::normalize::{hangul_decomposition_length, is_hangul_syllable};
-use crate::tables::stream_safe_leading_nonstarters;
-
-pub(crate) const MAX_NONSTARTERS: usize = 30;
-const COMBINING_GRAPHEME_JOINER: char = '\u{034F}';
-
-/// UAX15-D4: This iterator keeps track of how many non-starters there have been
-/// since the last starter in *NFKD* and will emit a Combining Grapheme Joiner
-/// (U+034F) if the count exceeds 30.
-pub struct StreamSafe<I> {
-    iter: I,
-    nonstarter_count: usize,
-    buffer: Option<char>,
-}
-
-impl<I> StreamSafe<I> {
-    pub(crate) fn new(iter: I) -> Self {
-        Self {
-            iter,
-            nonstarter_count: 0,
-            buffer: None,
-        }
-    }
-}
-
-impl<I: Iterator<Item = char>> Iterator for StreamSafe<I> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        let next_ch = match self.buffer.take().or_else(|| self.iter.next()) {
-            None => return None,
-            Some(c) => c,
-        };
-        let d = classify_nonstarters(next_ch);
-        if self.nonstarter_count + d.leading_nonstarters > MAX_NONSTARTERS {
-            // Since we're emitting a CGJ, the suffix of the emitted string in NFKD has no trailing
-            // nonstarters, so we can reset the counter to zero. Put `next_ch` back into the
-            // iterator (via `self.buffer`), and we'll reclassify it next iteration.
-            self.nonstarter_count = 0;
-            self.buffer = Some(next_ch);
-            return Some(COMBINING_GRAPHEME_JOINER);
-        }
-
-        // Is the character all nonstarters in NFKD? If so, increment our counter of contiguous
-        // nonstarters in NKFD.
-        if d.leading_nonstarters == d.decomposition_len {
-            self.nonstarter_count += d.decomposition_len;
-        }
-        // Otherwise, reset the counter to the decomposition's number of trailing nonstarters.
-        else {
-            self.nonstarter_count = d.trailing_nonstarters;
-        }
-        Some(next_ch)
-    }
-}
-
-impl<I: Iterator<Item = char> + FusedIterator> FusedIterator for StreamSafe<I> {}
-
-#[derive(Debug)]
-pub(crate) struct Decomposition {
-    pub(crate) leading_nonstarters: usize,
-    pub(crate) trailing_nonstarters: usize,
-    pub(crate) decomposition_len: usize,
-}
-
-#[inline]
-pub(crate) fn classify_nonstarters(c: char) -> Decomposition {
-    // As usual, fast path for ASCII (which is always a starter)
-    if c <= '\x7f' {
-        return Decomposition {
-            leading_nonstarters: 0,
-            trailing_nonstarters: 0,
-            decomposition_len: 1,
-        };
-    }
-    // Next, special case Hangul, since it's not handled by our tables.
-    if is_hangul_syllable(c) {
-        return Decomposition {
-            leading_nonstarters: 0,
-            trailing_nonstarters: 0,
-            decomposition_len: hangul_decomposition_length(c),
-        };
-    }
-    let decomp = compatibility_fully_decomposed(c).or_else(|| canonical_fully_decomposed(c));
-    match decomp {
-        Some(decomp) => Decomposition {
-            leading_nonstarters: stream_safe_leading_nonstarters(c),
-            trailing_nonstarters: stream_safe_trailing_nonstarters(c),
-            decomposition_len: decomp.len(),
-        },
-        None => {
-            let is_nonstarter = canonical_combining_class(c) != 0;
-            let nonstarter = if is_nonstarter { 1 } else { 0 };
-            Decomposition {
-                leading_nonstarters: nonstarter,
-                trailing_nonstarters: nonstarter,
-                decomposition_len: 1,
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{classify_nonstarters, StreamSafe};
-    use crate::lookups::canonical_combining_class;
-    use crate::normalize::decompose_compatible;
-
-    #[cfg(not(feature = "std"))]
-    use alloc::{string::String, vec::Vec};
-
-    use core::char;
-
-    fn stream_safe(s: &str) -> String {
-        StreamSafe::new(s.chars()).collect()
-    }
-
-    #[test]
-    fn test_simple() {
-        let technically_okay = "Da\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}ngerzone";
-        assert_eq!(stream_safe(technically_okay), technically_okay);
-
-        let too_much = "Da\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}\u{032e}ngerzone";
-        let fixed_it = "Da\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}\u{034f}\u{032e}ngerzone";
-        assert_eq!(stream_safe(too_much), fixed_it);
-
-        let woah_nelly = "Da\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}\u{032e}\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}\u{032e}ngerzone";
-        let its_cool = "Da\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{031d}\u{034f}\u{032e}\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{0316}\u{0317}\u{0318}\u{0319}\u{031a}\u{031b}\u{031c}\u{034f}\u{031d}\u{032e}ngerzone";
-        assert_eq!(stream_safe(woah_nelly), its_cool);
-    }
-
-    #[test]
-    fn test_all_nonstarters() {
-        let s = "\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}\u{0300}";
-        let expected = "\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{034F}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}\u{300}";
-        assert_eq!(stream_safe(s), expected);
-    }
-
-    #[test]
-    fn test_classify_nonstarters() {
-        // Highest character in the `compat_fully_decomp` table is 2FA1D
-        for ch in 0..0x2FA1E {
-            let ch = match char::from_u32(ch) {
-                Some(c) => c,
-                None => continue,
-            };
-            let c = classify_nonstarters(ch);
-            let mut s = Vec::new();
-            decompose_compatible(ch, |c| s.push(c));
-
-            assert_eq!(s.len(), c.decomposition_len);
-
-            let num_leading = s
-                .iter()
-                .take_while(|&c| canonical_combining_class(*c) != 0)
-                .count();
-            let num_trailing = s
-                .iter()
-                .rev()
-                .take_while(|&c| canonical_combining_class(*c) != 0)
-                .count();
-
-            assert_eq!(num_leading, c.leading_nonstarters);
-            assert_eq!(num_trailing, c.trailing_nonstarters);
-        }
-    }
-}
diff --git a/third_party/rust/unicode-normalization/src/tables.rs b/third_party/rust/unicode-normalization/src/tables.rs
@@ -1,22803 +0,0 @@
-// Copyright 2012-2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
-
-#![allow(missing_docs)]
-use crate::quick_check::IsNormalized;
-use crate::quick_check::IsNormalized::*;
-
-#[allow(unused)]
-pub const UNICODE_VERSION: (u8, u8, u8) = (16, 0, 0);
-
-pub(crate) const CANONICAL_COMBINING_CLASS_SALT: &[u16] = &[
-    0x000, 0x001, 0x2E5, 0x085, 0x014, 0x000, 0x023, 0x092, 0x01C, 0x07A, 0x000, 0x001, 0x000,
-    0x000, 0x06C, 0x02B, 0x006, 0x000, 0x000, 0x000, 0x00F, 0x000, 0x001, 0x007, 0x03A, 0x009,
-    0x10D, 0x002, 0x01A, 0x000, 0x004, 0x008, 0x069, 0x000, 0x000, 0x002, 0x011, 0x000, 0x01E,
-    0x000, 0x07E, 0x01B, 0x005, 0x002, 0x008, 0x000, 0x007, 0x004, 0x006, 0x00E, 0x000, 0x00A,
-    0x002, 0x057, 0x022, 0x000, 0x013, 0x001, 0x005, 0x000, 0x000, 0x02D, 0x000, 0x000, 0x000,
-    0x000, 0x001, 0x049, 0x003, 0x001, 0x057, 0x000, 0x012, 0x000, 0x000, 0x000, 0x005, 0x041,
-    0x000, 0x000, 0x003, 0x000, 0x003, 0x002, 0x002, 0x01D, 0x000, 0x000, 0x000, 0x011, 0x001,
-    0x000, 0x002, 0x001, 0x000, 0x00E, 0x000, 0x00B, 0x001, 0x006, 0x005, 0x000, 0x001, 0x000,
-    0x017, 0x000, 0x000, 0x001, 0x000, 0x000, 0x00A, 0x002, 0x000, 0x004, 0x00B, 0x018, 0x021,
-    0x00C, 0x001, 0x038, 0x000, 0x000, 0x002, 0x003, 0x001, 0x005, 0x000, 0x000, 0x00A, 0x01B,
-    0x001, 0x000, 0x000, 0x000, 0x019, 0x01A, 0x000, 0x000, 0x000, 0x004, 0x024, 0x003, 0x019,
-    0x004, 0x000, 0x00D, 0x001, 0x013, 0x000, 0x012, 0x004, 0x000, 0x006, 0x003, 0x006, 0x000,
-    0x002, 0x00F, 0x000, 0x000, 0x000, 0x000, 0x000, 0x011, 0x001, 0x011, 0x011, 0x005, 0x000,
-    0x00B, 0x013, 0x01E, 0x00A, 0x004, 0x001, 0x00C, 0x00A, 0x000, 0x000, 0x005, 0x003, 0x006,
-    0x000, 0x005, 0x009, 0x002, 0x000, 0x000, 0x009, 0x000, 0x001, 0x000, 0x029, 0x000, 0x012,
-    0x019, 0x004, 0x000, 0x000, 0x002, 0x00E, 0x003, 0x001, 0x00F, 0x005, 0x002, 0x001, 0x004,
-    0x007, 0x005, 0x000, 0x005, 0x002, 0x000, 0x000, 0x009, 0x000, 0x005, 0x003, 0x009, 0x001,
-    0x000, 0x000, 0x001, 0x000, 0x000, 0x009, 0x007, 0x007, 0x000, 0x000, 0x000, 0x006, 0x003,
-    0x000, 0x00A, 0x000, 0x000, 0x003, 0x007, 0x001, 0x000, 0x000, 0x001, 0x01A, 0x006, 0x000,
-    0x001, 0x009, 0x002, 0x008, 0x000, 0x001, 0x000, 0x008, 0x001, 0x009, 0x006, 0x015, 0x001,
-    0x000, 0x004, 0x000, 0x000, 0x000, 0x00C, 0x000, 0x005, 0x003, 0x000, 0x006, 0x000, 0x000,
-    0x008, 0x000, 0x000, 0x003, 0x007, 0x001, 0x000, 0x005, 0x001, 0x010, 0x007, 0x001, 0x005,
-    0x000, 0x000, 0x004, 0x004, 0x009, 0x00B, 0x001, 0x005, 0x004, 0x00A, 0x008, 0x003, 0x018,
-    0x000, 0x001, 0x002, 0x003, 0x000, 0x002, 0x000, 0x007, 0x000, 0x003, 0x000, 0x005, 0x007,
-    0x009, 0x00F, 0x006, 0x000, 0x005, 0x003, 0x009, 0x00B, 0x013, 0x002, 0x001, 0x000, 0x001,
-    0x001, 0x000, 0x001, 0x000, 0x001, 0x003, 0x00F, 0x000, 0x004, 0x000, 0x000, 0x007, 0x007,
-    0x002, 0x000, 0x000, 0x000, 0x002, 0x004, 0x00B, 0x000, 0x00C, 0x001, 0x000, 0x000, 0x002,
-    0x004, 0x008, 0x002, 0x002, 0x000, 0x006, 0x000, 0x00B, 0x001, 0x001, 0x00C, 0x006, 0x000,
-    0x004, 0x002, 0x00B, 0x001, 0x000, 0x001, 0x000, 0x000, 0x005, 0x001, 0x001, 0x00E, 0x003,
-    0x005, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x003, 0x000, 0x000, 0x00A, 0x003,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x013, 0x000, 0x002, 0x00A, 0x000, 0x000, 0x003,
-    0x003, 0x001, 0x003, 0x007, 0x004, 0x002, 0x000, 0x002, 0x000, 0x004, 0x000, 0x001, 0x001,
-    0x00E, 0x001, 0x005, 0x001, 0x002, 0x006, 0x002, 0x003, 0x004, 0x006, 0x002, 0x003, 0x001,
-    0x001, 0x005, 0x001, 0x000, 0x00E, 0x003, 0x002, 0x007, 0x000, 0x000, 0x00A, 0x004, 0x000,
-    0x000, 0x000, 0x006, 0x000, 0x000, 0x000, 0x000, 0x005, 0x000, 0x006, 0x001, 0x000, 0x003,
-    0x005, 0x003, 0x001, 0x007, 0x001, 0x002, 0x008, 0x008, 0x002, 0x001, 0x004, 0x000, 0x005,
-    0x009, 0x002, 0x000, 0x001, 0x003, 0x010, 0x001, 0x004, 0x004, 0x004, 0x003, 0x000, 0x000,
-    0x001, 0x000, 0x002, 0x000, 0x000, 0x001, 0x001, 0x010, 0x002, 0x003, 0x000, 0x000, 0x000,
-    0x003, 0x001, 0x001, 0x003, 0x000, 0x000, 0x002, 0x000, 0x001, 0x001, 0x000, 0x005, 0x002,
-    0x000, 0x002, 0x003, 0x000, 0x006, 0x000, 0x000, 0x001, 0x001, 0x000, 0x000, 0x001, 0x000,
-    0x00A, 0x000, 0x007, 0x000, 0x001, 0x001, 0x000, 0x001, 0x001, 0x004, 0x003, 0x003, 0x002,
-    0x007, 0x003, 0x000, 0x007, 0x000, 0x000, 0x003, 0x000, 0x001, 0x00B, 0x001, 0x002, 0x005,
-    0x000, 0x003, 0x001, 0x000, 0x000, 0x003, 0x000, 0x002, 0x000, 0x000, 0x000, 0x002, 0x001,
-    0x000, 0x001, 0x002, 0x001, 0x004, 0x005, 0x004, 0x000, 0x003, 0x002, 0x000, 0x000, 0x001,
-    0x005, 0x002, 0x007, 0x001, 0x001, 0x000, 0x001, 0x000, 0x001, 0x003, 0x003, 0x002, 0x004,
-    0x000, 0x001, 0x001, 0x001, 0x000, 0x000, 0x003, 0x002, 0x005, 0x000, 0x005, 0x00F, 0x002,
-    0x000, 0x001, 0x001, 0x000, 0x002, 0x000, 0x000, 0x000, 0x001, 0x000, 0x003, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x002, 0x001, 0x001, 0x003, 0x000, 0x001, 0x003, 0x001,
-    0x000, 0x000, 0x002, 0x000, 0x005, 0x003, 0x000, 0x006, 0x001, 0x002, 0x002, 0x003, 0x001,
-    0x003, 0x005, 0x006, 0x000, 0x002, 0x003, 0x00A, 0x000, 0x001, 0x001, 0x002, 0x002, 0x002,
-    0x004, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x005, 0x004, 0x001, 0x000, 0x000, 0x003,
-    0x001, 0x000, 0x000, 0x002, 0x000, 0x002, 0x001, 0x001, 0x002, 0x003, 0x000, 0x002, 0x000,
-    0x001, 0x000, 0x002, 0x003, 0x000, 0x002, 0x002, 0x001, 0x000, 0x001, 0x000, 0x001, 0x004,
-    0x001, 0x000, 0x004, 0x004, 0x001, 0x000, 0x000, 0x001, 0x001, 0x003, 0x001, 0x000, 0x000,
-    0x001, 0x002, 0x002, 0x009, 0x001, 0x005, 0x002, 0x002, 0x001, 0x000, 0x002, 0x006, 0x00D,
-    0x001, 0x002, 0x006, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x007, 0x000, 0x004,
-    0x002, 0x000, 0x002, 0x003, 0x001, 0x000, 0x002, 0x000, 0x001, 0x003, 0x000, 0x001, 0x000,
-    0x001, 0x000, 0x003, 0x002, 0x001, 0x006, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000,
-    0x003, 0x003, 0x000, 0x000, 0x000, 0x000, 0x000, 0x009, 0x000, 0x000, 0x000, 0x002, 0x001,
-    0x001, 0x003, 0x001, 0x001, 0x000, 0x005, 0x000, 0x003, 0x002, 0x003, 0x001, 0x001, 0x002,
-    0x000, 0x003, 0x001, 0x001, 0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x002, 0x003, 0x001,
-    0x001, 0x000, 0x001, 0x005, 0x004, 0x000, 0x003, 0x003, 0x000, 0x002, 0x003, 0x001, 0x001,
-    0x005, 0x003, 0x001, 0x000, 0x000, 0x001, 0x002, 0x001, 0x003, 0x00A, 0x004, 0x000, 0x001,
-    0x003, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x005, 0x002, 0x000, 0x001, 0x001,
-    0x000, 0x000, 0x006, 0x005, 0x003, 0x000, 0x000, 0x002, 0x000, 0x001, 0x000, 0x001, 0x001,
-    0x001, 0x001, 0x001, 0x000, 0x000, 0x00B, 0x004, 0x000, 0x002, 0x001, 0x002, 0x002, 0x001,
-    0x001, 0x000, 0x001, 0x002, 0x001, 0x001, 0x001, 0x002, 0x002, 0x000, 0x004, 0x001, 0x002,
-    0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x000, 0x000, 0x008, 0x001, 0x001, 0x000, 0x002, 0x002, 0x003, 0x002, 0x001, 0x001, 0x002,
-    0x000, 0x001, 0x000, 0x000, 0x009, 0x001, 0x001, 0x000, 0x001, 0x000, 0x003, 0x000, 0x001,
-    0x006, 0x001, 0x001, 0x000, 0x003, 0x001, 0x001, 0x001, 0x001, 0x004, 0x002, 0x002, 0x001,
-    0x000, 0x001, 0x003, 0x004, 0x000, 0x003, 0x000, 0x000, 0x001, 0x001, 0x001,
-];
-pub(crate) const CANONICAL_COMBINING_CLASS_KV: &[u32] = &[
-    0x0034AE6, 0x00E3A09, 0x01DFADA, 0x00818E6, 0x0FE20E6, 0x0A67CE6, 0x020D201, 0x02DFEE6,
-    0x008CCE6, 0x00737DC, 0x01DEBE6, 0x0FE26E6, 0x0089DE6, 0x01A7AE6, 0x006EADC, 0x0A675E6,
-    0x02DF7E6, 0x0A8EBE6, 0x1193D09, 0x0064F1F, 0x00741E6, 0x10D6AE6, 0x0FE2DDC, 0x1E024E6,
-    0x00322CA, 0x1E023E6, 0x01ACBE6, 0x005BB14, 0x00359DC, 0x008CEE6, 0x00F7484, 0x01B6DE6,
-    0x0A8E6E6, 0x0030DE6, 0x00F7A82, 0x1117307, 0x00356DC, 0x00592E6, 0x0FE2BDC, 0x01DEEE6,
-    0x00360EA, 0x1E947E6, 0x1133B07, 0x02CF1E6, 0x1E02AE6, 0x1D182DC, 0x01DE6E6, 0x10EFDDC,
-    0x00736E6, 0x01DECE6, 0x008D6E6, 0x10D25E6, 0x008FDE6, 0x00744DC, 0x00ECA7A, 0x1136CE6,
-    0x009BC07, 0x01AB9DC, 0x1D1ADE6, 0x008E4E6, 0x01A79E6, 0x10F4DDC, 0x00825E6, 0x0AABFE6,
-    0x0AABEE6, 0x00953E6, 0x0A8E9E6, 0x008E3DC, 0x0064E1E, 0x006D6E6, 0x111CA07, 0x10D69E6,
-    0x00364E6, 0x10A3ADC, 0x01DC4E6, 0x0103A09, 0x00349DC, 0x00358E8, 0x00487E6, 0x01AB1E6,
-    0x0065020, 0x01CD0E6, 0x0FE28DC, 0x005B711, 0x020D5E6, 0x00819E6, 0x01C3707, 0x16AF301,
-    0x01DCADC, 0x01BF309, 0x01DDAE6, 0x0035FE9, 0x01DDDE6, 0x10F82E6, 0x00361EA, 0x11D4509,
-    0x00352E6, 0x01DF0E6, 0x0034CE6, 0x01CD7DC, 0x0033701, 0x1E2EDE6, 0x11373E6, 0x01B6EE6,
-    0x020EA01, 0x10EABE6, 0x007EFE6, 0x0081DE6, 0x1D16801, 0x1E8D6DC, 0x01CD401, 0x00367E6,
-    0x1D188E6, 0x01CE0E6, 0x008EAE6, 0x01CDAE6, 0x00735E6, 0x005C712, 0x00C4D09, 0x00323DC,
-    0x00598E6, 0x10F4AE6, 0x01DDFE6, 0x020E8DC, 0x11D9709, 0x01DE1E6, 0x00316DC, 0x01A7CE6,
-    0x1E945E6, 0x01DD9E6, 0x0085BDC, 0x00EC97A, 0x00D4D09, 0x02DF0E6, 0x0309908, 0x017D209,
-    0x0A67AE6, 0x1D1AAE6, 0x005B40E, 0x01DE3E6, 0x111C009, 0x1D1ACE6, 0x00357E6, 0x119E009,
-    0x0030BE6, 0x0033EE6, 0x01CE301, 0x01CF8E6, 0x00F8409, 0x01DCBE6, 0x00317DC, 0x00483E6,
-    0x10F4BDC, 0x00326DC, 0x01CD2E6, 0x020D0E6, 0x005C4E6, 0x01AB0E6, 0x0089ADC, 0x0081CE6,
-    0x01DE4E6, 0x1144607, 0x115C007, 0x1183A07, 0x10F49E6, 0x00659E6, 0x01B6FE6, 0x0032DDC,
-    0x00EB876, 0x1BC9E01, 0x00734DC, 0x1136AE6, 0x0032EDC, 0x020E501, 0x008FBE6, 0x02D7F09,
-    0x1E944E6, 0x1E018E6, 0x01DEFE6, 0x1E949E6, 0x02DEEE6, 0x0135FE6, 0x00309E6, 0x01AC2E6,
-    0x00485E6, 0x01DF8E4, 0x00F86E6, 0x00613E6, 0x008D9E6, 0x01CDDDC, 0x1104609, 0x00304E6,
-    0x008E6DC, 0x0081EE6, 0x01DF6E8, 0x0093C07, 0x0A8ECE6, 0x1D1ABE6, 0x006ECE6, 0x0064C1C,
-    0x008F5E6, 0x1D244E6, 0x1E014E6, 0x00FC6DC, 0x0A8E1E6, 0x005AADC, 0x00658E6, 0x1E020E6,
-    0x008D4E6, 0x1133C07, 0x00302E6, 0x01AC4DC, 0x01DC6E6, 0x01AB4E6, 0x1D170D8, 0x0135EE6,
-    0x0059EE6, 0x008FFE6, 0x00739DC, 0x10AE5E6, 0x1E8D2DC, 0x1107009, 0x00308E6, 0x02CF0E6,
-    0x01DF3E6, 0x0A67DE6, 0x01DCED6, 0x0033ADC, 0x1D166D8, 0x00733E6, 0x11F4109, 0x0036BE6,
-    0x01CDEDC, 0x1E012E6, 0x0108DDC, 0x00611E6, 0x00ABC07, 0x01CEDDC, 0x1E026E6, 0x00343E6,
-    0x020D901, 0x1E948E6, 0x116B707, 0x00746DC, 0x01DE8E6, 0x020D7E6, 0x02DEFE6, 0x00355DC,
-    0x01A77E6, 0x00E3867, 0x0FE24E6, 0x1113309, 0x11369E6, 0x02DF4E6, 0x10EFFDC, 0x006EDDC,
-    0x0FE29DC, 0x0031EDC, 0x01DFCE9, 0x00F35DC, 0x1E4EEDC, 0x10D6DE6, 0x1D171D8, 0x11A9909,
-    0x00303E6, 0x10377E6, 0x1E015E6, 0x00313E6, 0x00332DC, 0x11368E6, 0x10D6CE6, 0x0A92DDC,
-    0x006E1E6, 0x00362E9, 0x00596DC, 0x0067023, 0x10F4FDC, 0x1123509, 0x01DC3E6, 0x10A0FE6,
-    0x02DF8E6, 0x0A8E4E6, 0x0032CDC, 0x00D3B09, 0x1D165D8, 0x0171409, 0x01CE601, 0x01ABBE6,
-    0x008DAE6, 0x00B3C07, 0x008F11C, 0x10AE6DC, 0x1E8D5DC, 0x00745E6, 0x01AC0DC, 0x020EEDC,
-    0x01CDFDC, 0x02DF9E6, 0x01AC5E6, 0x00597E6, 0x0302BE4, 0x00897E6, 0x1144209, 0x006DBE6,
-    0x0A80609, 0x113CE09, 0x0035DEA, 0x0FE2FE6, 0x00CBC07, 0x01DC7E6, 0x006E7E6, 0x00321CA,
-    0x00369E6, 0x00F7C82, 0x0031AE8, 0x02DF1E6, 0x008E8E6, 0x16AF201, 0x00740E6, 0x01DFDDC,
-    0x1E5EEE6, 0x11D4207, 0x01ABADC, 0x0A8E2E6, 0x112E907, 0x1D16901, 0x1E010E6, 0x1E000E6,
-    0x005B00A, 0x005C5DC, 0x0302FE0, 0x01A78E6, 0x1113409, 0x1E006E6, 0x01DE9E6, 0x008CFDC,
-    0x01DCCE6, 0x00F7D82, 0x006DCE6, 0x0173409, 0x0103909, 0x01BE607, 0x00731DC, 0x00312E6,
-    0x1E8D4DC, 0x00829E6, 0x008FADC, 0x1E029E6, 0x00823E6, 0x0030CE6, 0x01AB6DC, 0x1E135E6,
-    0x01DC8E6, 0x01DEDE6, 0x0035ADC, 0x00732E6, 0x0A8EDE6, 0x0AAB3E6, 0x1E028E6, 0x008F6DC,
-    0x008E7E6, 0x1E4ECE8, 0x0073CDC, 0x01DF7E4, 0x005ACE6, 0x020EFDC, 0x01CF4E6, 0x00368E6,
-    0x1E01CE6, 0x1D18ADC, 0x0FE21E6, 0x01DDCE6, 0x020D4E6, 0x0059BDC, 0x16B32E6, 0x0035BE6,
-    0x008D2DC, 0x0031BD8, 0x0A677E6, 0x1E003E6, 0x00DCA09, 0x0031DDC, 0x10F4CE6, 0x00F19DC,
-    0x01DFFDC, 0x0135DE6, 0x0030FE6, 0x02DE5E6, 0x0033801, 0x01ACEE6, 0x00743E6, 0x0193AE6,
-    0x10A3F09, 0x00CCD09, 0x01B71E6, 0x00954E6, 0x0089CE6, 0x020E601, 0x008F01B, 0x00657E6,
-    0x0FE23E6, 0x00311E6, 0x10EACE6, 0x020D301, 0x0064B1B, 0x020DBE6, 0x008DEE6, 0x0065DE6,
-    0x1E009E6, 0x0A674E6, 0x008CDE6, 0x01CE701, 0x008F21D, 0x0089EE6, 0x01DD1E6, 0x00324DC,
-    0x10A38E6, 0x01CD1E6, 0x01CD5DC, 0x1E132E6, 0x00EC87A, 0x01DCDEA, 0x0FE25E6, 0x0061A20,
-    0x00301E6, 0x005A1E6, 0x008F8E6, 0x1D186E6, 0x00305E6, 0x16B30E6, 0x01DF4E6, 0x00730E6,
-    0x00821E6, 0x007F1E6, 0x114C307, 0x0033DE6, 0x01DC2DC, 0x00615E6, 0x006E3DC, 0x01A17E6,
-    0x0089FE6, 0x0AAB0E6, 0x01DD5E6, 0x1E01FE6, 0x0082AE6, 0x00325DC, 0x11374E6, 0x10376E6,
-    0x0081BE6, 0x02DFFE6, 0x1D16FD8, 0x00484E6, 0x00318DC, 0x1E8D0DC, 0x005A6DC, 0x1193E09,
-    0x00F39D8, 0x1E00CE6, 0x00591DC, 0x1D187E6, 0x01B6CDC, 0x01DD0CA, 0x006D8E6, 0x01B3407,
-    0x02DEAE6, 0x1163F09, 0x008DDE6, 0x00F87E6, 0x02DE3E6, 0x00300E6, 0x0A6F1E6, 0x02DF2E6,
-    0x005A7DC, 0x01DF2E6, 0x00820E6, 0x00365E6, 0x1D17BDC, 0x01AB7DC, 0x1D16ED8, 0x0034DDC,
-    0x1E2EEE6, 0x0ABED09, 0x0AAB7E6, 0x0A8EFE6, 0x00614E6, 0x11C3F09, 0x102E0DC, 0x00ACD09,
-    0x0171509, 0x01AC6E6, 0x005B610, 0x11A3409, 0x0035EEA, 0x00310E6, 0x16AF401, 0x1E01EE6,
-    0x0032ADC, 0x0AAB2E6, 0x0A9C009, 0x00366E6, 0x005B50F, 0x009FEE6, 0x006DFE6, 0x0FE22E6,
-    0x1E8D3DC, 0x00340E6, 0x01DD8E6, 0x10F48E6, 0x02DFAE6, 0x1D17CDC, 0x0A678E6, 0x00826E6,
-    0x0A82C09, 0x01DE0E6, 0x0A8E0E6, 0x10F83DC, 0x0302DDE, 0x01DF5E6, 0x01B73E6, 0x1E00FE6,
-    0x1D16701, 0x01A6009, 0x02DE1E6, 0x0036CE6, 0x006EBE6, 0x00C565B, 0x01DE7E6, 0x00B4D09,
-    0x1E00DE6, 0x02DFDE6, 0x008F7E6, 0x00655DC, 0x0A67BE6, 0x00333DC, 0x005C118, 0x11366E6,
-    0x1D16DE2, 0x006181E, 0x0033FE6, 0x1E946E6, 0x0FE27DC, 0x007F0E6, 0x1E002E6, 0x114C209,
-    0x1E01DE6, 0x0A95309, 0x16B33E6, 0x1E01BE6, 0x01CE201, 0x01ACDE6, 0x00610E6, 0x0FE2CDC,
-    0x0A676E6, 0x16AF001, 0x020D6E6, 0x1D17FDC, 0x1D181DC, 0x005B913, 0x00827E6, 0x008D3DC,
-    0x115BF09, 0x005A0E6, 0x0065222, 0x008DFE6, 0x00653E6, 0x01CE401, 0x113CF09, 0x01A76E6,
-    0x006E2E6, 0x110B909, 0x10F46DC, 0x11A4709, 0x11370E6, 0x01CF9E6, 0x0065EE6, 0x00616E6,
-    0x02DFBE6, 0x1136BE6, 0x00656DC, 0x00348DC, 0x10D26E6, 0x01DD6E6, 0x008FCE6, 0x1145EE6,
-    0x00654E6, 0x008ECE6, 0x008CAE6, 0x020F0E6, 0x01DD7E6, 0x0030AE6, 0x00328CA, 0x00314E6,
-    0x0085ADC, 0x0034BE6, 0x1D189E6, 0x1E00AE6, 0x008DBE6, 0x10F4EDC, 0x005B812, 0x00320DC,
-    0x01DDEE6, 0x01B6BE6, 0x01AC3DC, 0x0033BDC, 0x01ACCE6, 0x005B30D, 0x0073FE6, 0x01AC1E6,
-    0x0302CE8, 0x01CD6DC, 0x00F37DC, 0x01DC1E6, 0x01DFEE6, 0x018A9E4, 0x020EB01, 0x008EFDC,
-    0x00347DC, 0x1123607, 0x00486E6, 0x00749E6, 0x017DDE6, 0x11102E6, 0x00617E6, 0x00D3C09,
-    0x0A8EAE6, 0x008EDDC, 0x00351E6, 0x00A3C07, 0x1E2ECE6, 0x116B609, 0x1E011E6, 0x020E1E6,
-    0x10D6BE6, 0x005C219, 0x01A7BE6, 0x007EEE6, 0x0036EE6, 0x008F9DC, 0x01DEAE6, 0x00BCD09,
-    0x005B10B, 0x01AB3E6, 0x11372E6, 0x008D7E6, 0x1D17EDC, 0x0A8EEE6, 0x008DCE6, 0x16B31E6,
-    0x02DE7E6, 0x0065121, 0x006E4E6, 0x0059CE6, 0x00342E6, 0x0AAB4DC, 0x00595E6, 0x16B36E6,
-    0x0030EE6, 0x0033501, 0x0036FE6, 0x00816E6, 0x0302EE0, 0x00353DC, 0x0031CDC, 0x00315E8,
-    0x01B72E6, 0x005A2DC, 0x02DF6E6, 0x008EEDC, 0x0082DE6, 0x01CD8DC, 0x005BA13, 0x01AC7E6,
-    0x01AB2E6, 0x0033CDC, 0x01939DE, 0x0103707, 0x0A8F1E6, 0x00612E6, 0x10F84E6, 0x0073BDC,
-    0x1E008E6, 0x007EDE6, 0x020EDDC, 0x00E4A6B, 0x16FF106, 0x110BA07, 0x00346E6, 0x008FEE6,
-    0x00331DC, 0x00C3C07, 0x1E00EE6, 0x00ECB7A, 0x005ABE6, 0x16AF101, 0x01ABCE6, 0x0081FE6,
-    0x01BAA09, 0x10D24E6, 0x0A92CDC, 0x005A8E6, 0x1037AE6, 0x0059DE6, 0x01B70E6, 0x006E8E6,
-    0x00F7181, 0x02DE4E6, 0x16B34E6, 0x02DEDE6, 0x00A4D09, 0x0A92BDC, 0x0082CE6, 0x1E2EFE6,
-    0x1D242E6, 0x00354DC, 0x0032BDC, 0x0193BDC, 0x008D1DC, 0x0073EDC, 0x1E005E6, 0x00319DC,
-    0x02DEBE6, 0x0073AE6, 0x01AC8E6, 0x00F82E6, 0x1E133E6, 0x1D180DC, 0x0033601, 0x00EBA09,
-    0x0AAF609, 0x02DF5E6, 0x00307E6, 0x01DC0E6, 0x10F85DC, 0x0032FDC, 0x0035CE9, 0x01CDBE6,
-    0x00330DC, 0x01AB5DC, 0x01DDBE6, 0x02DE9E6, 0x00F7282, 0x1E131E6, 0x00363E6, 0x16FF006,
-    0x007ECE6, 0x112EA09, 0x10378E6, 0x007FDDC, 0x0302ADA, 0x0065BE6, 0x006191F, 0x00F18DC,
-    0x1172B09, 0x00952DC, 0x00F83E6, 0x00898E6, 0x00899DC, 0x10A3901, 0x1134D09, 0x01DF1E6,
-    0x0309A08, 0x00747E6, 0x01DE2E6, 0x1E8D1DC, 0x10EFEDC, 0x1E013E6, 0x0034EDC, 0x005B20C,
-    0x16B35E6, 0x00859DC, 0x1107F09, 0x00738DC, 0x005A3DC, 0x11367E6, 0x01ACADC, 0x01A7FDC,
-    0x1E08FE6, 0x11100E6, 0x0065AE6, 0x11D4409, 0x01DCFDC, 0x0065CDC, 0x01DD3E6, 0x005AEE4,
-    0x1E016E6, 0x008EBE6, 0x0031FDC, 0x00EB976, 0x1E004E6, 0x0033401, 0x0074AE6, 0x01DF9DC,
-    0x01CE801, 0x0064D1D, 0x020D1E6, 0x0A8E5E6, 0x1D243E6, 0x0094D09, 0x00E4B6B, 0x007F3E6,
-    0x005ADDE, 0x005A4DC, 0x008F4E6, 0x11F4209, 0x0AAC1E6, 0x1D185E6, 0x02DECE6, 0x0A8F0E6,
-    0x01DE5E6, 0x00306E6, 0x0A8E3E6, 0x00951E6, 0x11101E6, 0x02DE8E6, 0x00748DC, 0x0A8E8E6,
-    0x1E4EDE8, 0x006DAE6, 0x01CE501, 0x0AAB8E6, 0x10A0DDC, 0x00822E6, 0x00327CA, 0x1612F09,
-    0x1E017E6, 0x00339DC, 0x02DE6E6, 0x020E7E6, 0x00345F0, 0x0FE2EE6, 0x10379E6, 0x0071124,
-    0x101FDDC, 0x0082BE6, 0x01B4409, 0x00329DC, 0x00350E6, 0x005AFE6, 0x02DFCE6, 0x008D8E6,
-    0x00C5554, 0x00817E6, 0x1E021E6, 0x01AC9E6, 0x00593E6, 0x01DD2E6, 0x0A9B307, 0x01DC9E6,
-    0x00341E6, 0x008D0DC, 0x0A6F0E6, 0x008E0E6, 0x01A75E6, 0x01DC5E6, 0x0059FE6, 0x01ABDDC,
-    0x01ABFDC, 0x1E5EFDC, 0x00594E6, 0x005A5DC, 0x007F2DC, 0x01BAB09, 0x01BF209, 0x1E4EFE6,
-    0x005A9E6, 0x008F3E6, 0x1E00BE6, 0x1D172D8, 0x006D7E6, 0x006D9E6, 0x0036AE6, 0x01CD9DC,
-    0x10F47DC, 0x0A69FE6, 0x005BC15, 0x008E1E6, 0x1E134E6, 0x0065FDC, 0x0A8E7E6, 0x1E001E6,
-    0x1E027E6, 0x1E2AEE6, 0x01DFBE6, 0x00E486B, 0x01AB8DC, 0x01A18DC, 0x020D801, 0x0FB1E1A,
-    0x0A66FE6, 0x02DE2E6, 0x02DF3E6, 0x00599E6, 0x1183909, 0x113D009, 0x00E3967, 0x0059ADE,
-    0x10D27E6, 0x0073DE6, 0x10F50DC, 0x008CBE6, 0x01DD4E6, 0x02CEFE6, 0x00742DC, 0x1D18BDC,
-    0x008D5E6, 0x01CDCDC, 0x02DE0E6, 0x0089BDC, 0x0A679E6, 0x020E9E6, 0x008E9DC, 0x1E130E6,
-    0x020DA01, 0x020DCE6, 0x1194307, 0x006E0E6, 0x0A69EE6, 0x008E5E6, 0x1E136E6, 0x020ECDC,
-    0x00E496B, 0x0036DE6, 0x11371E6, 0x005BF17, 0x0A8C409, 0x007EBE6, 0x0FE2ADC, 0x1D17DDC,
-    0x009CD09, 0x005BD16, 0x00F8082, 0x00344E6, 0x00F7B82, 0x1E94A07,
-];
-
-pub(crate) const COMPOSITION_TABLE_SALT: &[u16] = &[
-    0x000, 0x000, 0x000, 0x000, 0x25D, 0x003, 0x05D, 0x000, 0x002, 0x009, 0x004, 0x087, 0x006,
-    0x135, 0x001, 0x000, 0x000, 0x004, 0x003, 0x0E1, 0x078, 0x000, 0x002, 0x029, 0x008, 0x08F,
-    0x024, 0x000, 0x000, 0x000, 0x031, 0x000, 0x000, 0x06D, 0x000, 0x033, 0x001, 0x04C, 0x000,
-    0x001, 0x000, 0x000, 0x008, 0x07C, 0x006, 0x04C, 0x045, 0x02A, 0x002, 0x000, 0x000, 0x000,
-    0x00A, 0x000, 0x000, 0x059, 0x000, 0x010, 0x003, 0x009, 0x00E, 0x006, 0x001, 0x00C, 0x010,
-    0x000, 0x000, 0x000, 0x03D, 0x000, 0x000, 0x02A, 0x000, 0x000, 0x001, 0x020, 0x00A, 0x000,
-    0x001, 0x00E, 0x002, 0x010, 0x022, 0x000, 0x061, 0x000, 0x004, 0x015, 0x000, 0x004, 0x003,
-    0x000, 0x000, 0x003, 0x000, 0x00D, 0x001, 0x001, 0x024, 0x003, 0x004, 0x000, 0x000, 0x018,
-    0x058, 0x000, 0x000, 0x00A, 0x019, 0x010, 0x000, 0x002, 0x000, 0x000, 0x012, 0x015, 0x000,
-    0x00C, 0x007, 0x003, 0x000, 0x01A, 0x007, 0x00C, 0x001, 0x005, 0x004, 0x021, 0x001, 0x002,
-    0x000, 0x000, 0x001, 0x00A, 0x000, 0x00A, 0x000, 0x004, 0x009, 0x005, 0x00D, 0x005, 0x000,
-    0x003, 0x006, 0x026, 0x00B, 0x000, 0x004, 0x006, 0x000, 0x013, 0x000, 0x000, 0x004, 0x001,
-    0x000, 0x000, 0x000, 0x024, 0x001, 0x01D, 0x001, 0x000, 0x000, 0x010, 0x000, 0x001, 0x001,
-    0x001, 0x000, 0x000, 0x00A, 0x000, 0x00D, 0x000, 0x010, 0x000, 0x006, 0x005, 0x000, 0x000,
-    0x009, 0x003, 0x001, 0x000, 0x000, 0x000, 0x000, 0x002, 0x001, 0x002, 0x000, 0x000, 0x016,
-    0x001, 0x002, 0x000, 0x001, 0x000, 0x006, 0x001, 0x025, 0x005, 0x000, 0x00A, 0x00D, 0x002,
-    0x000, 0x001, 0x000, 0x000, 0x012, 0x000, 0x000, 0x001, 0x000, 0x001, 0x000, 0x001, 0x000,
-    0x004, 0x009, 0x000, 0x001, 0x004, 0x000, 0x004, 0x001, 0x006, 0x00B, 0x003, 0x006, 0x007,
-    0x000, 0x000, 0x000, 0x00D, 0x00F, 0x00E, 0x000, 0x001, 0x001, 0x004, 0x00F, 0x010, 0x000,
-    0x005, 0x000, 0x019, 0x001, 0x00E, 0x000, 0x008, 0x001, 0x003, 0x000, 0x000, 0x005, 0x001,
-    0x000, 0x000, 0x011, 0x000, 0x004, 0x005, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x002,
-    0x001, 0x000, 0x000, 0x002, 0x001, 0x001, 0x005, 0x008, 0x000, 0x000, 0x00C, 0x00A, 0x000,
-    0x006, 0x009, 0x003, 0x001, 0x006, 0x001, 0x000, 0x01B, 0x001, 0x00E, 0x000, 0x008, 0x005,
-    0x003, 0x015, 0x000, 0x002, 0x007, 0x00B, 0x003, 0x000, 0x00A, 0x003, 0x000, 0x006, 0x000,
-    0x00A, 0x000, 0x001, 0x003, 0x008, 0x000, 0x009, 0x000, 0x001, 0x002, 0x000, 0x005, 0x000,
-    0x001, 0x000, 0x000, 0x000, 0x017, 0x000, 0x000, 0x002, 0x000, 0x005, 0x016, 0x000, 0x010,
-    0x003, 0x004, 0x011, 0x001, 0x003, 0x000, 0x000, 0x000, 0x004, 0x001, 0x000, 0x005, 0x000,
-    0x002, 0x001, 0x000, 0x002, 0x000, 0x002, 0x002, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000,
-    0x012, 0x001, 0x004, 0x00A, 0x00B, 0x004, 0x000, 0x002, 0x000, 0x003, 0x000, 0x004, 0x005,
-    0x000, 0x000, 0x011, 0x001, 0x006, 0x006, 0x000, 0x002, 0x000, 0x001, 0x000, 0x004, 0x000,
-    0x000, 0x001, 0x001, 0x007, 0x000, 0x003, 0x00A, 0x000, 0x001, 0x00A, 0x002, 0x000, 0x001,
-    0x000, 0x000, 0x00D, 0x005, 0x001, 0x001, 0x000, 0x000, 0x005, 0x006, 0x008, 0x004, 0x005,
-    0x000, 0x00B, 0x000, 0x004, 0x00B, 0x000, 0x000, 0x001, 0x005, 0x000, 0x00B, 0x000, 0x006,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x004, 0x000, 0x006, 0x000, 0x000, 0x007, 0x013,
-    0x004, 0x019, 0x003, 0x001, 0x000, 0x001, 0x006, 0x006, 0x000, 0x000, 0x000, 0x000, 0x00C,
-    0x002, 0x003, 0x000, 0x004, 0x000, 0x001, 0x000, 0x001, 0x005, 0x001, 0x001, 0x002, 0x001,
-    0x000, 0x000, 0x000, 0x000, 0x009, 0x000, 0x000, 0x007, 0x001, 0x009, 0x006, 0x004, 0x001,
-    0x005, 0x000, 0x001, 0x002, 0x008, 0x000, 0x009, 0x000, 0x000, 0x001, 0x003, 0x00B, 0x000,
-    0x001, 0x000, 0x000, 0x005, 0x000, 0x000, 0x000, 0x000, 0x000, 0x003, 0x000, 0x002, 0x001,
-    0x002, 0x000, 0x000, 0x000, 0x004, 0x001, 0x000, 0x006, 0x002, 0x005, 0x008, 0x012, 0x000,
-    0x000, 0x000, 0x003, 0x001, 0x000, 0x000, 0x000, 0x002, 0x003, 0x003, 0x000, 0x000, 0x001,
-    0x000, 0x001, 0x000, 0x003, 0x000, 0x000, 0x002, 0x001, 0x004, 0x00D, 0x000, 0x000, 0x00B,
-    0x000, 0x001, 0x000, 0x000, 0x00C, 0x000, 0x000, 0x000, 0x005, 0x008, 0x002, 0x000, 0x002,
-    0x001, 0x006, 0x001, 0x001, 0x001, 0x000, 0x002, 0x000, 0x005, 0x001, 0x001, 0x000, 0x002,
-    0x000, 0x000, 0x000, 0x000, 0x00E, 0x010, 0x000, 0x005, 0x004, 0x002, 0x001, 0x000, 0x000,
-    0x003, 0x001, 0x000, 0x002, 0x001, 0x004, 0x000, 0x000, 0x003, 0x000, 0x001, 0x001, 0x003,
-    0x001, 0x005, 0x002, 0x003, 0x004, 0x000, 0x003, 0x003, 0x006, 0x000, 0x000, 0x001, 0x000,
-    0x002, 0x00E, 0x001, 0x002, 0x001, 0x004, 0x002, 0x005, 0x002, 0x001, 0x001, 0x000, 0x001,
-    0x000, 0x005, 0x005, 0x006, 0x006, 0x005, 0x000, 0x002, 0x001, 0x000, 0x002, 0x004, 0x001,
-    0x000, 0x005, 0x000, 0x006, 0x002, 0x008, 0x000, 0x000, 0x007, 0x001, 0x002, 0x002, 0x005,
-    0x004, 0x011, 0x000, 0x003, 0x000, 0x001, 0x000, 0x001, 0x004, 0x000, 0x003, 0x002, 0x000,
-    0x001, 0x003, 0x000, 0x00B, 0x006, 0x000, 0x006, 0x000, 0x004, 0x001, 0x002, 0x000, 0x001,
-    0x000, 0x002, 0x001, 0x002, 0x000, 0x005, 0x001, 0x000, 0x000, 0x000, 0x001, 0x003, 0x002,
-    0x006, 0x000, 0x000, 0x002, 0x004, 0x006, 0x000, 0x000, 0x000, 0x000, 0x00C, 0x00C, 0x000,
-    0x000, 0x000, 0x004, 0x004, 0x000, 0x008, 0x003, 0x001, 0x000, 0x001, 0x000, 0x003, 0x000,
-    0x000, 0x005, 0x000, 0x005, 0x001, 0x000, 0x003, 0x004, 0x001, 0x002, 0x003, 0x000, 0x001,
-    0x007, 0x000, 0x000, 0x007, 0x000, 0x002, 0x002, 0x000, 0x000, 0x001, 0x001, 0x001, 0x001,
-    0x00B, 0x000, 0x004, 0x000, 0x001, 0x001, 0x000, 0x002, 0x001, 0x001, 0x005, 0x000, 0x000,
-    0x003, 0x006, 0x000, 0x000, 0x004, 0x002, 0x001, 0x003, 0x003, 0x00A, 0x007, 0x000, 0x004,
-    0x001, 0x006, 0x000, 0x001, 0x000, 0x000, 0x002, 0x001, 0x001, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x002, 0x001, 0x001, 0x001, 0x004, 0x000, 0x003, 0x000, 0x001, 0x000, 0x000, 0x001,
-    0x000, 0x001, 0x000, 0x004, 0x000, 0x001, 0x000, 0x006, 0x000, 0x001, 0x000, 0x004, 0x000,
-    0x001, 0x002, 0x006, 0x000, 0x002, 0x000, 0x003, 0x007, 0x000, 0x003, 0x000, 0x001, 0x001,
-    0x000, 0x000, 0x003, 0x005, 0x002, 0x000, 0x001, 0x001, 0x002, 0x002, 0x004, 0x001, 0x000,
-    0x000, 0x001, 0x000, 0x003, 0x002, 0x000, 0x001, 0x000, 0x002, 0x004, 0x002, 0x000, 0x001,
-    0x005, 0x000, 0x000, 0x002, 0x001, 0x001, 0x000, 0x000, 0x001, 0x000, 0x005, 0x002, 0x000,
-    0x008, 0x003, 0x001, 0x001, 0x001, 0x003, 0x004, 0x000, 0x002, 0x000, 0x001, 0x002, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x006, 0x000, 0x000, 0x000, 0x003, 0x000, 0x000,
-    0x002, 0x002, 0x000, 0x001, 0x003, 0x001, 0x003, 0x001, 0x002, 0x000, 0x001, 0x002, 0x000,
-    0x000, 0x001, 0x000, 0x003, 0x001, 0x002, 0x000, 0x002, 0x001, 0x000, 0x002, 0x004, 0x000,
-    0x005, 0x005, 0x000, 0x005, 0x002, 0x000, 0x001, 0x003, 0x001, 0x000, 0x002, 0x006, 0x002,
-    0x001, 0x000, 0x000, 0x000, 0x003,
-];
-pub(crate) const COMPOSITION_TABLE_KV: &[(u32, char)] = &[
-    (0x064A0654, '\u{000626}'),
-    (0x00690309, '\u{001EC9}'),
-    (0x00650306, '\u{000115}'),
-    (0x0423030B, '\u{0004F2}'),
-    (0x0047030C, '\u{0001E6}'),
-    (0x00570301, '\u{001E82}'),
-    (0x00C50301, '\u{0001FA}'),
-    (0x21D20338, '\u{0021CF}'),
-    (0x00430307, '\u{00010A}'),
-    (0x007A0307, '\u{00017C}'),
-    (0x0049030C, '\u{0001CF}'),
-    (0x00720307, '\u{001E59}'),
-    (0x304B3099, '\u{00304C}'),
-    (0x1F610345, '\u{001FA1}'),
-    (0x00410307, '\u{000226}'),
-    (0x006B0323, '\u{001E33}'),
-    (0x03990304, '\u{001FD9}'),
-    (0x1F490301, '\u{001F4D}'),
-    (0x03CA0342, '\u{001FD7}'),
-    (0x00550304, '\u{00016A}'),
-    (0x30DB309A, '\u{0030DD}'),
-    (0x1F6E0345, '\u{001FAE}'),
-    (0x00420331, '\u{001E06}'),
-    (0x041E0308, '\u{0004E6}'),
-    (0x00410325, '\u{001E00}'),
-    (0x00520331, '\u{001E5E}'),
-    (0x1FF60345, '\u{001FF7}'),
-    (0x22720338, '\u{002274}'),
-    (0x22480338, '\u{002249}'),
-    (0x1FBF0301, '\u{001FCE}'),
-    (0x30C63099, '\u{0030C7}'),
-    (0x00760323, '\u{001E7F}'),
-    (0x00700307, '\u{001E57}'),
-    (0x1F510301, '\u{001F55}'),
-    (0x00750328, '\u{000173}'),
-    (0x305B3099, '\u{00305C}'),
-    (0x0041030A, '\u{0000C5}'),
-    (0x01A10323, '\u{001EE3}'),
-    (0x00550311, '\u{000216}'),
-    (0x00530307, '\u{001E60}'),
-    (0x00DC030C, '\u{0001D9}'),
-    (0x004F0300, '\u{0000D2}'),
-    (0x006F0307, '\u{00022F}'),
-    (0x00470301, '\u{0001F4}'),
-    (0x00610309, '\u{001EA3}'),
-    (0x1F080301, '\u{001F0C}'),
-    (0x03B90301, '\u{0003AF}'),
-    (0x04330301, '\u{000453}'),
-    (0x1F200345, '\u{001F90}'),
-    (0x00620307, '\u{001E03}'),
-    (0x1F030345, '\u{001F83}'),
-    (0x00570308, '\u{001E84}'),
-    (0x005A0307, '\u{00017B}'),
-    (0x30C13099, '\u{0030C2}'),
-    (0x01A10309, '\u{001EDF}'),
-    (0x06270655, '\u{000625}'),
-    (0x03BF0314, '\u{001F41}'),
-    (0x00670301, '\u{0001F5}'),
-    (0x039F0301, '\u{00038C}'),
-    (0x00EA0301, '\u{001EBF}'),
-    (0x0063030C, '\u{00010D}'),
-    (0x1F000345, '\u{001F80}'),
-    (0x04130301, '\u{000403}'),
-    (0x004B0323, '\u{001E32}'),
-    (0x00790301, '\u{0000FD}'),
-    (0x00770301, '\u{001E83}'),
-    (0x1F0E0345, '\u{001F8E}'),
-    (0x00480308, '\u{001E26}'),
-    (0x30A63099, '\u{0030F4}'),
-    (0x01020300, '\u{001EB0}'),
-    (0x006C0301, '\u{00013A}'),
-    (0x00450309, '\u{001EBA}'),
-    (0x1F390301, '\u{001F3D}'),
-    (0x00690311, '\u{00020B}'),
-    (0x04230304, '\u{0004EE}'),
-    (0x0061030C, '\u{0001CE}'),
-    (0x1F100300, '\u{001F12}'),
-    (0x04380300, '\u{00045D}'),
-    (0x00480323, '\u{001E24}'),
-    (0x1B111B35, '\u{001B12}'),
-    (0x00430301, '\u{000106}'),
-    (0x00540323, '\u{001E6C}'),
-    (0x00490303, '\u{000128}'),
-    (0x1EA10302, '\u{001EAD}'),
-    (0x04350308, '\u{000451}'),
-    (0x00610307, '\u{000227}'),
-    (0x1F000300, '\u{001F02}'),
-    (0x006D0307, '\u{001E41}'),
-    (0x00760303, '\u{001E7D}'),
-    (0x00730327, '\u{00015F}'),
-    (0x00470304, '\u{001E20}'),
-    (0x00470306, '\u{00011E}'),
-    (0x1F6D0345, '\u{001FAD}'),
-    (0x006F0303, '\u{0000F5}'),
-    (0x006B0331, '\u{001E35}'),
-    (0x00720331, '\u{001E5F}'),
-    (0x01B00300, '\u{001EEB}'),
-    (0x1B0B1B35, '\u{001B0C}'),
-    (0x0055032D, '\u{001E76}'),
-    (0x0061030A, '\u{0000E5}'),
-    (0x30463099, '\u{003094}'),
-    (0x1B3A1B35, '\u{001B3B}'),
-    (0x0055030A, '\u{00016E}'),
-    (0x0928093C, '\u{000929}'),
-    (0x03C90313, '\u{001F60}'),
-    (0x00650330, '\u{001E1B}'),
-    (0x00590303, '\u{001EF8}'),
-    (0x00450330, '\u{001E1A}'),
-    (0x00640331, '\u{001E0F}'),
-    (0x03B90308, '\u{0003CA}'),
-    (0x309D3099, '\u{00309E}'),
-    (0x0443030B, '\u{0004F3}'),
-    (0x0B470B3E, '\u{000B4B}'),
-    (0x006F030F, '\u{00020D}'),
-    (0x006E0323, '\u{001E47}'),
-    (0x00690308, '\u{0000EF}'),
-    (0x0065032D, '\u{001E19}'),
-    (0x015A0307, '\u{001E64}'),
-    (0x1F180301, '\u{001F1C}'),
-    (0x1F090301, '\u{001F0D}'),
-    (0x1F270345, '\u{001F97}'),
-    (0x007A0302, '\u{001E91}'),
-    (0x00590301, '\u{0000DD}'),
-    (0x004C0331, '\u{001E3A}'),
-    (0x1F640345, '\u{001FA4}'),
-    (0x1EB90302, '\u{001EC7}'),
-    (0x1F240345, '\u{001F94}'),
-    (0x01130300, '\u{001E15}'),
-    (0x0069030F, '\u{000209}'),
-    (0x00740331, '\u{001E6F}'),
-    (0x1F480301, '\u{001F4C}'),
-    (0x007A0331, '\u{001E95}'),
-    (0x1F290345, '\u{001F99}'),
-    (0x00D40301, '\u{001ED0}'),
-    (0x00C40304, '\u{0001DE}'),
-    (0x03970301, '\u{000389}'),
-    (0x0072030C, '\u{000159}'),
-    (0x1F110301, '\u{001F15}'),
-    (0x00F40309, '\u{001ED5}'),
-    (0x00450327, '\u{000228}'),
-    (0x006F031B, '\u{0001A1}'),
-    (0x00C60304, '\u{0001E2}'),
-    (0x03990308, '\u{0003AA}'),
-    (0x03CE0345, '\u{001FF4}'),
-    (0x006D0301, '\u{001E3F}'),
-    (0x01030309, '\u{001EB3}'),
-    (0x006F0302, '\u{0000F4}'),
-    (0x0073030C, '\u{000161}'),
-    (0x00750301, '\u{0000FA}'),
-    (0x1F690301, '\u{001F6D}'),
-    (0x03A90301, '\u{00038F}'),
-    (0x003D0338, '\u{002260}'),
-    (0x1FC60345, '\u{001FC7}'),
-    (0x00770300, '\u{001E81}'),
-    (0x02280306, '\u{001E1C}'),
-    (0x006C0331, '\u{001E3B}'),
-    (0x30AD3099, '\u{0030AE}'),
-    (0x1EB80302, '\u{001EC6}'),
-    (0x00550302, '\u{0000DB}'),
-    (0x0DD90DCF, '\u{000DDC}'),
-    (0x03A50304, '\u{001FE9}'),
-    (0x03A90314, '\u{001F69}'),
-    (0x00740327, '\u{000163}'),
-    (0x00530326, '\u{000218}'),
-    (0x0055030B, '\u{000170}'),
-    (0x306F309A, '\u{003071}'),
-    (0x006B0327, '\u{000137}'),
-    (0x00750330, '\u{001E75}'),
-    (0x00730301, '\u{00015B}'),
-    (0x1F300342, '\u{001F36}'),
-    (0x00470307, '\u{000120}'),
-    (0x0CC60CD5, '\u{000CC7}'),
-    (0x1F690300, '\u{001F6B}'),
-    (0x01030301, '\u{001EAF}'),
-    (0x00750311, '\u{000217}'),
-    (0x0930093C, '\u{000931}'),
-    (0x30613099, '\u{003062}'),
-    (0x00770323, '\u{001E89}'),
-    (0x00F50301, '\u{001E4D}'),
-    (0x00FC0300, '\u{0001DC}'),
-    (0x0049030F, '\u{000208}'),
-    (0x00690302, '\u{0000EE}'),
-    (0x1F230345, '\u{001F93}'),
-    (0x00F40300, '\u{001ED3}'),
-    (0x044B0308, '\u{0004F9}'),
-    (0x1F2E0345, '\u{001F9E}'),
-    (0x00650300, '\u{0000E8}'),
-    (0x00490308, '\u{0000CF}'),
-    (0x1F280301, '\u{001F2C}'),
-    (0x1F180300, '\u{001F1A}'),
-    (0x06270653, '\u{000622}'),
-    (0x1F200301, '\u{001F24}'),
-    (0x22030338, '\u{002204}'),
-    (0x00790304, '\u{000233}'),
-    (0x1F390300, '\u{001F3B}'),
-    (0x00610325, '\u{001E01}'),
-    (0x00790309, '\u{001EF7}'),
-    (0x01AF0303, '\u{001EEE}'),
-    (0x006F0301, '\u{0000F3}'),
-    (0x00640323, '\u{001E0D}'),
-    (0x304F3099, '\u{003050}'),
-    (0x1F010345, '\u{001F81}'),
-    (0x00CA0309, '\u{001EC2}'),
-    (0x03D20308, '\u{0003D4}'),
-    (0x1F500301, '\u{001F54}'),
-    (0x1F010300, '\u{001F03}'),
-    (0x03A90345, '\u{001FFC}'),
-    (0x04270308, '\u{0004F4}'),
-    (0x00530302, '\u{00015C}'),
-    (0x00520301, '\u{000154}'),
-    (0x00450306, '\u{000114}'),
-    (0x00530323, '\u{001E62}'),
-    (0x00670306, '\u{00011F}'),
-    (0x22760338, '\u{002278}'),
-    (0x04350300, '\u{000450}'),
-    (0x30B53099, '\u{0030B6}'),
-    (0x006F030B, '\u{000151}'),
-    (0x04180304, '\u{0004E2}'),
-    (0x00630307, '\u{00010B}'),
-    (0x03D20301, '\u{0003D3}'),
-    (0x227C0338, '\u{0022E0}'),
-    (0x00610304, '\u{000101}'),
-    (0x00A80300, '\u{001FED}'),
-    (0x00440331, '\u{001E0E}'),
-    (0x00650311, '\u{000207}'),
-    (0x00F80301, '\u{0001FF}'),
-    (0x0075030C, '\u{0001D4}'),
-    (0x00530327, '\u{00015E}'),
-    (0x30573099, '\u{003058}'),
-    (0x03B70345, '\u{001FC3}'),
-    (0x0069030C, '\u{0001D0}'),
-    (0x006E0327, '\u{000146}'),
-    (0x00780307, '\u{001E8B}'),
-    (0x1F000342, '\u{001F06}'),
-    (0x01B00303, '\u{001EEF}'),
-    (0x00470327, '\u{000122}'),
-    (0x00C20309, '\u{001EA8}'),
-    (0x006C032D, '\u{001E3D}'),
-    (0x304D3099, '\u{00304E}'),
-    (0x00690303, '\u{000129}'),
-    (0x01AF0323, '\u{001EF0}'),
-    (0x004F0302, '\u{0000D4}'),
-    (0x01020301, '\u{001EAE}'),
-    (0x04470308, '\u{0004F5}'),
-    (0x22A80338, '\u{0022AD}'),
-    (0x03C50300, '\u{001F7A}'),
-    (0x03910313, '\u{001F08}'),
-    (0x0064032D, '\u{001E13}'),
-    (0x00CF0301, '\u{001E2E}'),
-    (0x0061030F, '\u{000201}'),
-    (0x1EA10306, '\u{001EB7}'),
-    (0x00790323, '\u{001EF5}'),
-    (0x21900338, '\u{00219A}'),
-    (0x1F250345, '\u{001F95}'),
-    (0x004F0304, '\u{00014C}'),
-    (0x004F0306, '\u{00014E}'),
-    (0x30B33099, '\u{0030B4}'),
-    (0x00440327, '\u{001E10}'),
-    (0x0B920BD7, '\u{000B94}'),
-    (0x00550308, '\u{0000DC}'),
-    (0x00650323, '\u{001EB9}'),
-    (0x307B3099, '\u{00307C}'),
-    (0x004F030C, '\u{0001D1}'),
-    (0x00670304, '\u{001E21}'),
-    (0x006A030C, '\u{0001F0}'),
-    (0x00550323, '\u{001EE4}'),
-    (0x01A10301, '\u{001EDB}'),
-    (0x00590323, '\u{001EF4}'),
-    (0x00410300, '\u{0000C0}'),
-    (0x30B93099, '\u{0030BA}'),
-    (0x04230308, '\u{0004F0}'),
-    (0x00530301, '\u{00015A}'),
-    (0x30D8309A, '\u{0030DA}'),
-    (0x00750309, '\u{001EE7}'),
-    (0x00550330, '\u{001E74}'),
-    (0x00520327, '\u{000156}'),
-    (0x04370308, '\u{0004DF}'),
-    (0x00CA0300, '\u{001EC0}'),
-    (0x21940338, '\u{0021AE}'),
-    (0x03B10306, '\u{001FB0}'),
-    (0x1F610342, '\u{001F67}'),
-    (0x223C0338, '\u{002241}'),
-    (0x30D23099, '\u{0030D3}'),
-    (0x1F6B0345, '\u{001FAB}'),
-    (0x00490307, '\u{000130}'),
-    (0x00410323, '\u{001EA0}'),
-    (0x00550309, '\u{001EE6}'),
-    (0x0075030B, '\u{000171}'),
-    (0x30533099, '\u{003054}'),
-    (0x305D3099, '\u{00305E}'),
-    (0x004C0323, '\u{001E36}'),
-    (0x02260304, '\u{0001E0}'),
-    (0x0475030F, '\u{000477}'),
-    (0x00490328, '\u{00012E}'),
-    (0x1F210300, '\u{001F23}'),
-    (0x1F610301, '\u{001F65}'),
-    (0x1F210342, '\u{001F27}'),
-    (0x00670302, '\u{00011D}'),
-    (0x004E0301, '\u{000143}'),
-    (0x004E0303, '\u{0000D1}'),
-    (0x03990300, '\u{001FDA}'),
-    (0x03BF0301, '\u{0003CC}'),
-    (0x04150300, '\u{000400}'),
-    (0x03C90314, '\u{001F61}'),
-    (0x22A20338, '\u{0022AC}'),
-    (0x30DB3099, '\u{0030DC}'),
-    (0x03A50314, '\u{001F59}'),
-    (0x0052030F, '\u{000210}'),
-    (0x004E0323, '\u{001E46}'),
-    (0x1F0D0345, '\u{001F8D}'),
-    (0x1ECD0302, '\u{001ED9}'),
-    (0x00FC030C, '\u{0001DA}'),
-    (0x00D60304, '\u{00022A}'),
-    (0x1F000301, '\u{001F04}'),
-    (0x30CF3099, '\u{0030D0}'),
-    (0x04350306, '\u{0004D7}'),
-    (0x220B0338, '\u{00220C}'),
-    (0x00590300, '\u{001EF2}'),
-    (0x04170308, '\u{0004DE}'),
-    (0x006E030C, '\u{000148}'),
-    (0x004C030C, '\u{00013D}'),
-    (0x01690301, '\u{001E79}'),
-    (0x04100308, '\u{0004D2}'),
-    (0x01A00301, '\u{001EDA}'),
-    (0x0041030F, '\u{000200}'),
-    (0x00720301, '\u{000155}'),
-    (0x00450303, '\u{001EBC}'),
-    (0x1B0D1B35, '\u{001B0E}'),
-    (0x01120301, '\u{001E16}'),
-    (0x004A0302, '\u{000134}'),
-    (0x03BF0300, '\u{001F78}'),
-    (0x30593099, '\u{00305A}'),
-    (0x004F030B, '\u{000150}'),
-    (0x00610328, '\u{000105}'),
-    (0x30D83099, '\u{0030D9}'),
-    (0x1F2B0345, '\u{001F9B}'),
-    (0x1F400301, '\u{001F44}'),
-    (0x0065030F, '\u{000205}'),
-    (0x03AE0345, '\u{001FC4}'),
-    (0x01680301, '\u{001E78}'),
-    (0x00740326, '\u{00021B}'),
-    (0x03B90342, '\u{001FD6}'),
-    (0x1F6F0345, '\u{001FAF}'),
-    (0x03A50301, '\u{00038E}'),
-    (0x1F090345, '\u{001F89}'),
-    (0x00550300, '\u{0000D9}'),
-    (0x0041030C, '\u{0001CD}'),
-    (0x00430327, '\u{0000C7}'),
-    (0x00460307, '\u{001E1E}'),
-    (0x03B50301, '\u{0003AD}'),
-    (0x0D470D3E, '\u{000D4B}'),
-    (0x00610311, '\u{000203}'),
-    (0x00D50308, '\u{001E4E}'),
-    (0x03C90300, '\u{001F7C}'),
-    (0x04430306, '\u{00045E}'),
-    (0x1FFE0301, '\u{001FDE}'),
-    (0x03990301, '\u{00038A}'),
-    (0x00790307, '\u{001E8F}'),
-    (0x1E5A0304, '\u{001E5C}'),
-    (0x0075030F, '\u{000215}'),
-    (0x09C709BE, '\u{0009CB}'),
-    (0x1B071B35, '\u{001B08}'),
-    (0x00690330, '\u{001E2D}'),
-    (0x307B309A, '\u{00307D}'),
-    (0x30C83099, '\u{0030C9}'),
-    (0x22B30338, '\u{0022EB}'),
-    (0x01B00301, '\u{001EE9}'),
-    (0x00790300, '\u{001EF3}'),
-    (0x00570307, '\u{001E86}'),
-    (0x00690328, '\u{00012F}'),
-    (0x005A0323, '\u{001E92}'),
-    (0x03C50342, '\u{001FE6}'),
-    (0x004F0309, '\u{001ECE}'),
-    (0x1F290342, '\u{001F2F}'),
-    (0x01A00300, '\u{001EDC}'),
-    (0x1F2A0345, '\u{001F9A}'),
-    (0x014D0301, '\u{001E53}'),
-    (0x21D00338, '\u{0021CD}'),
-    (0x00550328, '\u{000172}'),
-    (0x00680331, '\u{001E96}'),
-    (0x0068030C, '\u{00021F}'),
-    (0x004C0301, '\u{000139}'),
-    (0x22860338, '\u{002288}'),
-    (0x039F0314, '\u{001F49}'),
-    (0x03A50306, '\u{001FE8}'),
-    (0x0B470B56, '\u{000B48}'),
-    (0x30753099, '\u{003076}'),
-    (0x1E5B0304, '\u{001E5D}'),
-    (0x1F6A0345, '\u{001FAA}'),
-    (0x00540327, '\u{000162}'),
-    (0x01020303, '\u{001EB4}'),
-    (0x039F0313, '\u{001F48}'),
-    (0x1F090342, '\u{001F0F}'),
-    (0x04100306, '\u{0004D0}'),
-    (0x014D0300, '\u{001E51}'),
-    (0x04430304, '\u{0004EF}'),
-    (0x21920338, '\u{00219B}'),
-    (0x22610338, '\u{002262}'),
-    (0x00F50304, '\u{00022D}'),
-    (0x03B90313, '\u{001F30}'),
-    (0x006F0308, '\u{0000F6}'),
-    (0x00730307, '\u{001E61}'),
-    (0x0075031B, '\u{0001B0}'),
-    (0x30B73099, '\u{0030B8}'),
-    (0x1E620307, '\u{001E68}'),
-    (0x00410306, '\u{000102}'),
-    (0x03970314, '\u{001F29}'),
-    (0x00630302, '\u{000109}'),
-    (0x006A0302, '\u{000135}'),
-    (0x00E50301, '\u{0001FB}'),
-    (0x00730326, '\u{000219}'),
-    (0x1F740345, '\u{001FC2}'),
-    (0x00650309, '\u{001EBB}'),
-    (0x005A030C, '\u{00017D}'),
-    (0x22250338, '\u{002226}'),
-    (0x03A90313, '\u{001F68}'),
-    (0x00720327, '\u{000157}'),
-    (0x1F090300, '\u{001F0B}'),
-    (0x04360308, '\u{0004DD}'),
-    (0x1F080345, '\u{001F88}'),
-    (0x00620331, '\u{001E07}'),
-    (0x22730338, '\u{002275}'),
-    (0x00560323, '\u{001E7E}'),
-    (0x004F0323, '\u{001ECC}'),
-    (0x022E0304, '\u{000230}'),
-    (0x06D50654, '\u{0006C0}'),
-    (0x03B10313, '\u{001F00}'),
-    (0x004F0303, '\u{0000D5}'),
-    (0x1F010301, '\u{001F05}'),
-    (0x00650304, '\u{000113}'),
-    (0x00450323, '\u{001EB8}'),
-    (0x0BC60BBE, '\u{000BCA}'),
-    (0x22650338, '\u{002271}'),
-    (0x03910314, '\u{001F09}'),
-    (0x01120300, '\u{001E14}'),
-    (0x004E0307, '\u{001E44}'),
-    (0x00680308, '\u{001E27}'),
-    (0x004F0311, '\u{00020E}'),
-    (0x00550303, '\u{000168}'),
-    (0x03A10314, '\u{001FEC}'),
-    (0x03B10301, '\u{0003AC}'),
-    (0x0055030F, '\u{000214}'),
-    (0x003E0338, '\u{00226F}'),
-    (0x01610307, '\u{001E67}'),
-    (0x1F040345, '\u{001F84}'),
-    (0x00450300, '\u{0000C8}'),
-    (0x1B091B35, '\u{001B0A}'),
-    (0x30FD3099, '\u{0030FE}'),
-    (0x1F680301, '\u{001F6C}'),
-    (0x00650303, '\u{001EBD}'),
-    (0x03B90304, '\u{001FD1}'),
-    (0x09C709D7, '\u{0009CC}'),
-    (0x042B0308, '\u{0004F8}'),
-    (0x004E0327, '\u{000145}'),
-    (0x1F630345, '\u{001FA3}'),
-    (0x04380306, '\u{000439}'),
-    (0x03B10314, '\u{001F01}'),
-    (0x00540326, '\u{00021A}'),
-    (0x00740307, '\u{001E6B}'),
-    (0x03C90301, '\u{0003CE}'),
-    (0x03990314, '\u{001F39}'),
-    (0x30B13099, '\u{0030B2}'),
-    (0x00750302, '\u{0000FB}'),
-    (0x0CC60CD6, '\u{000CC8}'),
-    (0x30BD3099, '\u{0030BE}'),
-    (0x006E0300, '\u{0001F9}'),
-    (0x1F390342, '\u{001F3F}'),
-    (0x02270304, '\u{0001E1}'),
-    (0x22080338, '\u{002209}'),
-    (0x04180306, '\u{000419}'),
-    (0x0044030C, '\u{00010E}'),
-    (0x0075030A, '\u{00016F}'),
-    (0x06270654, '\u{000623}'),
-    (0x00750306, '\u{00016D}'),
-    (0x03B70300, '\u{001F74}'),
-    (0x1F660345, '\u{001FA6}'),
-    (0x1F690345, '\u{001FA9}'),
-    (0x015B0307, '\u{001E65}'),
-    (0x1F280342, '\u{001F2E}'),
-    (0x1F700345, '\u{001FB2}'),
-    (0x1F0F0345, '\u{001F8F}'),
-    (0x00540331, '\u{001E6E}'),
-    (0x227B0338, '\u{002281}'),
-    (0x22870338, '\u{002289}'),
-    (0x1F010342, '\u{001F07}'),
-    (0x03A50308, '\u{0003AB}'),
-    (0x1F650345, '\u{001FA5}'),
-    (0x00D40300, '\u{001ED2}'),
-    (0x00F60304, '\u{00022B}'),
-    (0x0CBF0CD5, '\u{000CC0}'),
-    (0x1F380342, '\u{001F3E}'),
-    (0x22B20338, '\u{0022EA}'),
-    (0x0072030F, '\u{000211}'),
-    (0x30BF3099, '\u{0030C0}'),
-    (0x04E90308, '\u{0004EB}'),
-    (0x22830338, '\u{002285}'),
-    (0x03CB0300, '\u{001FE2}'),
-    (0x00CA0301, '\u{001EBE}'),
-    (0x00590304, '\u{000232}'),
-    (0x00690301, '\u{0000ED}'),
-    (0x305F3099, '\u{003060}'),
-    (0x00440307, '\u{001E0A}'),
-    (0x1ECC0302, '\u{001ED8}'),
-    (0x1F210345, '\u{001F91}'),
-    (0x00410311, '\u{000202}'),
-    (0x00720311, '\u{000213}'),
-    (0x03A50300, '\u{001FEA}'),
-    (0x1F590300, '\u{001F5B}'),
-    (0x00E40304, '\u{0001DF}'),
-    (0x1F500300, '\u{001F52}'),
-    (0x224D0338, '\u{00226D}'),
-    (0x006E0301, '\u{000144}'),
-    (0x0075032D, '\u{001E77}'),
-    (0x00F40301, '\u{001ED1}'),
-    (0x03C90342, '\u{001FF6}'),
-    (0x03B70301, '\u{0003AE}'),
-    (0x006E0307, '\u{001E45}'),
-    (0x00410304, '\u{000100}'),
-    (0x1F190301, '\u{001F1D}'),
-    (0x03B10304, '\u{001FB1}'),
-    (0x3078309A, '\u{00307A}'),
-    (0x00570323, '\u{001E88}'),
-    (0x04430308, '\u{0004F1}'),
-    (0x0045032D, '\u{001E18}'),
-    (0x04150308, '\u{000401}'),
-    (0x004F0328, '\u{0001EA}'),
-    (0x04D90308, '\u{0004DB}'),
-    (0x04060308, '\u{000407}'),
-    (0x00F40303, '\u{001ED7}'),
-    (0x03B90306, '\u{001FD0}'),
-    (0x00650307, '\u{000117}'),
-    (0x1F680342, '\u{001F6E}'),
-    (0x04380304, '\u{0004E3}'),
-    (0x1F410300, '\u{001F43}'),
-    (0x1FFE0300, '\u{001FDD}'),
-    (0x004F0301, '\u{0000D3}'),
-    (0x00640327, '\u{001E11}'),
-    (0x02290306, '\u{001E1D}'),
-    (0x007A0301, '\u{00017A}'),
-    (0x00620323, '\u{001E05}'),
-    (0x1F7C0345, '\u{001FF2}'),
-    (0x01B00323, '\u{001EF1}'),
-    (0x1F600301, '\u{001F64}'),
-    (0x30663099, '\u{003067}'),
-    (0x22640338, '\u{002270}'),
-    (0x1F310300, '\u{001F33}'),
-    (0x00610323, '\u{001EA1}'),
-    (0x1F480300, '\u{001F4A}'),
-    (0x00550301, '\u{0000DA}'),
-    (0x0C460C56, '\u{000C48}'),
-    (0x03CA0300, '\u{001FD2}'),
-    (0x01B7030C, '\u{0001EE}'),
-    (0x00720323, '\u{001E5B}'),
-    (0x1F200342, '\u{001F26}'),
-    (0x04300308, '\u{0004D3}'),
-    (0x22820338, '\u{002284}'),
-    (0x1F590301, '\u{001F5D}'),
-    (0x1F080342, '\u{001F0E}'),
-    (0x00440323, '\u{001E0C}'),
-    (0x1025102E, '\u{001026}'),
-    (0x03910304, '\u{001FB9}'),
-    (0x004B0331, '\u{001E34}'),
-    (0x00690300, '\u{0000EC}'),
-    (0x0048032E, '\u{001E2A}'),
-    (0x00630301, '\u{000107}'),
-    (0x1F690342, '\u{001F6F}'),
-    (0x03B50313, '\u{001F10}'),
-    (0x30CF309A, '\u{0030D1}'),
-    (0x004E030C, '\u{000147}'),
-    (0x0B470B57, '\u{000B4C}'),
-    (0x03910301, '\u{000386}'),
-    (0x00650328, '\u{000119}'),
-    (0x1FBF0300, '\u{001FCD}'),
-    (0x03B70342, '\u{001FC6}'),
-    (0x00450307, '\u{000116}'),
-    (0x1F380301, '\u{001F3C}'),
-    (0x3075309A, '\u{003077}'),
-    (0x004B0301, '\u{001E30}'),
-    (0x01030300, '\u{001EB1}'),
-    (0x00E20303, '\u{001EAB}'),
-    (0x00410302, '\u{0000C2}'),
-    (0x00650308, '\u{0000EB}'),
-    (0x00580307, '\u{001E8A}'),
-    (0x0054030C, '\u{000164}'),
-    (0x03C50313, '\u{001F50}'),
-    (0x03B50314, '\u{001F11}'),
-    (0x1B3E1B35, '\u{001B40}'),
-    (0x1F100301, '\u{001F14}'),
-    (0x3072309A, '\u{003074}'),
-    (0x1F280345, '\u{001F98}'),
-    (0x22770338, '\u{002279}'),
-    (0x227A0338, '\u{002280}'),
-    (0x00470302, '\u{00011C}'),
-    (0x00450308, '\u{0000CB}'),
-    (0x00550324, '\u{001E72}'),
-    (0x1F2C0345, '\u{001F9C}'),
-    (0x004B0327, '\u{000136}'),
-    (0x00490302, '\u{0000CE}'),
-    (0x00680302, '\u{000125}'),
-    (0x00520307, '\u{001E58}'),
-    (0x00610301, '\u{0000E1}'),
-    (0x004B030C, '\u{0001E8}'),
-    (0x00490309, '\u{001EC8}'),
-    (0x006C030C, '\u{00013E}'),
-    (0x004D0307, '\u{001E40}'),
-    (0x1E360304, '\u{001E38}'),
-    (0x03C50304, '\u{001FE1}'),
-    (0x0079030A, '\u{001E99}'),
-    (0x03970313, '\u{001F28}'),
-    (0x0054032D, '\u{001E70}'),
-    (0x1F490300, '\u{001F4B}'),
-    (0x1B421B35, '\u{001B43}'),
-    (0x03B70313, '\u{001F20}'),
-    (0x00EF0301, '\u{001E2F}'),
-    (0x00E70301, '\u{001E09}'),
-    (0x016A0308, '\u{001E7A}'),
-    (0x00CA0303, '\u{001EC4}'),
-    (0x03B10300, '\u{001F70}'),
-    (0x06D20654, '\u{0006D3}'),
-    (0x30D53099, '\u{0030D6}'),
-    (0x1F2F0345, '\u{001F9F}'),
-    (0x03B50300, '\u{001F72}'),
-    (0x00750324, '\u{001E73}'),
-    (0x04150306, '\u{0004D6}'),
-    (0x0065030C, '\u{00011B}'),
-    (0x00570302, '\u{000174}'),
-    (0x1EA00306, '\u{001EB6}'),
-    (0x1F070345, '\u{001F87}'),
-    (0x00A80301, '\u{000385}'),
-    (0x00790302, '\u{000177}'),
-    (0x006E032D, '\u{001E4B}'),
-    (0x006F030C, '\u{0001D2}'),
-    (0x03C90345, '\u{001FF3}'),
-    (0x00430302, '\u{000108}'),
-    (0x00790303, '\u{001EF9}'),
-    (0x00740323, '\u{001E6D}'),
-    (0x00E20309, '\u{001EA9}'),
-    (0x1F300300, '\u{001F32}'),
-    (0x006B0301, '\u{001E31}'),
-    (0x22920338, '\u{0022E3}'),
-    (0x03950314, '\u{001F19}'),
-    (0x1F290301, '\u{001F2D}'),
-    (0x00450328, '\u{000118}'),
-    (0x1FB60345, '\u{001FB7}'),
-    (0x00D50304, '\u{00022C}'),
-    (0x04300306, '\u{0004D1}'),
-    (0x00F50308, '\u{001E4F}'),
-    (0x1EA00302, '\u{001EAC}'),
-    (0x1F680300, '\u{001F6A}'),
-    (0x03970300, '\u{001FCA}'),
-    (0x00450301, '\u{0000C9}'),
-    (0x00690304, '\u{00012B}'),
-    (0x0BC60BD7, '\u{000BCC}'),
-    (0x006F0304, '\u{00014D}'),
-    (0x004F0308, '\u{0000D6}'),
-    (0x0BC70BBE, '\u{000BCB}'),
-    (0x0055030C, '\u{0001D3}'),
-    (0x03AC0345, '\u{001FB4}'),
-    (0x1FBF0342, '\u{001FCF}'),
-    (0x30D2309A, '\u{0030D4}'),
-    (0x00660307, '\u{001E1F}'),
-    (0x004E0300, '\u{0001F8}'),
-    (0x00790308, '\u{0000FF}'),
-    (0x0068032E, '\u{001E2B}'),
-    (0x0064030C, '\u{00010F}'),
-    (0x004F0307, '\u{00022E}'),
-    (0x1F590342, '\u{001F5F}'),
-    (0x30AF3099, '\u{0030B0}'),
-    (0x00E60304, '\u{0001E3}'),
-    (0x03C50301, '\u{0003CD}'),
-    (0x00770308, '\u{001E85}'),
-    (0x03B90314, '\u{001F31}'),
-    (0x00750323, '\u{001EE5}'),
-    (0x00590309, '\u{001EF6}'),
-    (0x0292030C, '\u{0001EF}'),
-    (0x00550306, '\u{00016C}'),
-    (0x00E60301, '\u{0001FD}'),
-    (0x016B0308, '\u{001E7B}'),
-    (0x004F030F, '\u{00020C}'),
-    (0x03BF0313, '\u{001F40}'),
-    (0x00D80301, '\u{0001FE}'),
-    (0x00C20303, '\u{001EAA}'),
-    (0x1F510300, '\u{001F53}'),
-    (0x01B00309, '\u{001EED}'),
-    (0x004E032D, '\u{001E4A}'),
-    (0x006F0309, '\u{001ECF}'),
-    (0x04180300, '\u{00040D}'),
-    (0x22A90338, '\u{0022AE}'),
-    (0x1F680345, '\u{001FA8}'),
-    (0x1B3C1B35, '\u{001B3D}'),
-    (0x1F400300, '\u{001F42}'),
-    (0x1F0B0345, '\u{001F8B}'),
-    (0x03C50306, '\u{001FE0}'),
-    (0x0044032D, '\u{001E12}'),
-    (0x0CCA0CD5, '\u{000CCB}'),
-    (0x00EA0303, '\u{001EC5}'),
-    (0x04230306, '\u{00040E}'),
-    (0x00C70301, '\u{001E08}'),
-    (0x007A030C, '\u{00017E}'),
-    (0x00670307, '\u{000121}'),
-    (0x00450311, '\u{000206}'),
-    (0x006F0300, '\u{0000F2}'),
-    (0x30BB3099, '\u{0030BC}'),
-    (0x04180308, '\u{0004E4}'),
-    (0x30513099, '\u{003052}'),
-    (0x006C0323, '\u{001E37}'),
-    (0x03B70314, '\u{001F21}'),
-    (0x0077030A, '\u{001E98}'),
-    (0x00690323, '\u{001ECB}'),
-    (0x00610303, '\u{0000E3}'),
-    (0x30F13099, '\u{0030F9}'),
-    (0x03B10345, '\u{001FB3}'),
-    (0x0D460D3E, '\u{000D4A}'),
-    (0x03B90300, '\u{001F76}'),
-    (0x21D40338, '\u{0021CE}'),
-    (0x1F620345, '\u{001FA2}'),
-    (0x00770302, '\u{000175}'),
-    (0x00FC0304, '\u{0001D6}'),
-    (0x01130301, '\u{001E17}'),
-    (0x30683099, '\u{003069}'),
-    (0x1F600342, '\u{001F66}'),
-    (0x00680323, '\u{001E25}'),
-    (0x03950313, '\u{001F18}'),
-    (0x00EA0300, '\u{001EC1}'),
-    (0x03CB0342, '\u{001FE7}'),
-    (0x22430338, '\u{002244}'),
-    (0x30783099, '\u{003079}'),
-    (0x03990313, '\u{001F38}'),
-    (0x00490330, '\u{001E2C}'),
-    (0x00770307, '\u{001E87}'),
-    (0x00650301, '\u{0000E9}'),
-    (0x00680327, '\u{001E29}'),
-    (0x22B50338, '\u{0022ED}'),
-    (0x03B10342, '\u{001FB6}'),
-    (0x03910306, '\u{001FB8}'),
-    (0x004D0301, '\u{001E3E}'),
-    (0x00410309, '\u{001EA2}'),
-    (0x1B051B35, '\u{001B06}'),
-    (0x003C0338, '\u{00226E}'),
-    (0x00590308, '\u{000178}'),
-    (0x01030303, '\u{001EB5}'),
-    (0x00480327, '\u{001E28}'),
-    (0x006D0323, '\u{001E43}'),
-    (0x30643099, '\u{003065}'),
-    (0x04560308, '\u{000457}'),
-    (0x00590302, '\u{000176}'),
-    (0x06C10654, '\u{0006C2}'),
-    (0x043A0301, '\u{00045C}'),
-    (0x00E20300, '\u{001EA7}'),
-    (0x03950301, '\u{000388}'),
-    (0x00630327, '\u{0000E7}'),
-    (0x017F0307, '\u{001E9B}'),
-    (0x06480654, '\u{000624}'),
-    (0x30AB3099, '\u{0030AC}'),
-    (0x01A00323, '\u{001EE2}'),
-    (0x04D80308, '\u{0004DA}'),
-    (0x005A0331, '\u{001E94}'),
-    (0x0067030C, '\u{0001E7}'),
-    (0x039F0300, '\u{001FF8}'),
-    (0x00650327, '\u{000229}'),
-    (0x00490323, '\u{001ECA}'),
-    (0x1F110300, '\u{001F13}'),
-    (0x1F510342, '\u{001F57}'),
-    (0x004D0323, '\u{001E42}'),
-    (0x1F300301, '\u{001F34}'),
-    (0x006C0327, '\u{00013C}'),
-    (0x1F050345, '\u{001F85}'),
-    (0x01A10300, '\u{001EDD}'),
-    (0x04160308, '\u{0004DC}'),
-    (0x00640307, '\u{001E0B}'),
-    (0x004C032D, '\u{001E3C}'),
-    (0x03C10314, '\u{001FE5}'),
-    (0x01EA0304, '\u{0001EC}'),
-    (0x1F080300, '\u{001F0A}'),
-    (0x00650302, '\u{0000EA}'),
-    (0x03910300, '\u{001FBA}'),
-    (0x00700301, '\u{001E55}'),
-    (0x1F020345, '\u{001F82}'),
-    (0x01020309, '\u{001EB2}'),
-    (0x00750303, '\u{000169}'),
-    (0x1F0C0345, '\u{001F8C}'),
-    (0x03CB0301, '\u{0003B0}'),
-    (0x00740308, '\u{001E97}'),
-    (0x03950300, '\u{001FC8}'),
-    (0x227D0338, '\u{0022E1}'),
-    (0x007A0323, '\u{001E93}'),
-    (0x006F0311, '\u{00020F}'),
-    (0x006F0328, '\u{0001EB}'),
-    (0x1F200300, '\u{001F22}'),
-    (0x1F190300, '\u{001F1B}'),
-    (0x00560303, '\u{001E7C}'),
-    (0x006B030C, '\u{0001E9}'),
-    (0x04E80308, '\u{0004EA}'),
-    (0x03A90300, '\u{001FFA}'),
-    (0x00A80342, '\u{001FC1}'),
-    (0x04360306, '\u{0004C2}'),
-    (0x00DC0301, '\u{0001D7}'),
-    (0x00750304, '\u{00016B}'),
-    (0x22450338, '\u{002247}'),
-    (0x00490304, '\u{00012A}'),
-    (0x04380308, '\u{0004E5}'),
-    (0x0D460D57, '\u{000D4C}'),
-    (0x00750300, '\u{0000F9}'),
-    (0x22B40338, '\u{0022EC}'),
-    (0x00750308, '\u{0000FC}'),
-    (0x03C50314, '\u{001F51}'),
-    (0x01600307, '\u{001E66}'),
-    (0x04160306, '\u{0004C1}'),
-    (0x0055031B, '\u{0001AF}'),
-    (0x22AB0338, '\u{0022AF}'),
-    (0x014C0300, '\u{001E50}'),
-    (0x1F310342, '\u{001F37}'),
-    (0x1F260345, '\u{001F96}'),
-    (0x22910338, '\u{0022E2}'),
-    (0x00500301, '\u{001E54}'),
-    (0x004C0327, '\u{00013B}'),
-    (0x005A0301, '\u{000179}'),
-    (0x00420307, '\u{001E02}'),
-    (0x03C10313, '\u{001FE4}'),
-    (0x1F410301, '\u{001F45}'),
-    (0x00500307, '\u{001E56}'),
-    (0x0043030C, '\u{00010C}'),
-    (0x00730323, '\u{001E63}'),
-    (0x30553099, '\u{003056}'),
-    (0x306F3099, '\u{003070}'),
-    (0x044D0308, '\u{0004ED}'),
-    (0x1F670345, '\u{001FA7}'),
-    (0x01AF0301, '\u{001EE8}'),
-    (0x1F290300, '\u{001F2B}'),
-    (0x1B3F1B35, '\u{001B41}'),
-    (0x00450302, '\u{0000CA}'),
-    (0x006F0306, '\u{00014F}'),
-    (0x00FC0301, '\u{0001D8}'),
-    (0x30F23099, '\u{0030FA}'),
-    (0x1F2D0345, '\u{001F9D}'),
-    (0x014C0301, '\u{001E52}'),
-    (0x00610308, '\u{0000E4}'),
-    (0x1F600345, '\u{001FA0}'),
-    (0x1F0A0345, '\u{001F8A}'),
-    (0x00610306, '\u{000103}'),
-    (0x1F600300, '\u{001F62}'),
-    (0x01AF0300, '\u{001EEA}'),
-    (0x043E0308, '\u{0004E7}'),
-    (0x22230338, '\u{002224}'),
-    (0x03CA0301, '\u{000390}'),
-    (0x30D5309A, '\u{0030D7}'),
-    (0x1F220345, '\u{001F92}'),
-    (0x00D50301, '\u{001E4C}'),
-    (0x1F6C0345, '\u{001FAC}'),
-    (0x00540307, '\u{001E6A}'),
-    (0x1E370304, '\u{001E39}'),
-    (0x0DD90DCA, '\u{000DDA}'),
-    (0x01A10303, '\u{001EE1}'),
-    (0x0048030C, '\u{00021E}'),
-    (0x00EA0309, '\u{001EC3}'),
-    (0x0052030C, '\u{000158}'),
-    (0x00D40303, '\u{001ED6}'),
-    (0x0045030C, '\u{00011A}'),
-    (0x30EF3099, '\u{0030F7}'),
-    (0x00480302, '\u{000124}'),
-    (0x00520323, '\u{001E5A}'),
-    (0x00C20300, '\u{001EA6}'),
-    (0x0074032D, '\u{001E71}'),
-    (0x042D0308, '\u{0004EC}'),
-    (0x0DD90DDF, '\u{000DDE}'),
-    (0x00410308, '\u{0000C4}'),
-    (0x0474030F, '\u{000476}'),
-    (0x00C60301, '\u{0001FC}'),
-    (0x1F310301, '\u{001F35}'),
-    (0x1F610300, '\u{001F63}'),
-    (0x0CC60CC2, '\u{000CCA}'),
-    (0x00C20301, '\u{001EA4}'),
-    (0x03C50308, '\u{0003CB}'),
-    (0x00E20301, '\u{001EA5}'),
-    (0x1F500342, '\u{001F56}'),
-    (0x00610300, '\u{0000E0}'),
-    (0x00490311, '\u{00020A}'),
-    (0x00670327, '\u{000123}'),
-    (0x00590307, '\u{001E8E}'),
-    (0x03970345, '\u{001FCC}'),
-    (0x00D40309, '\u{001ED4}'),
-    (0x01A00303, '\u{001EE0}'),
-    (0x1FFE0342, '\u{001FDF}'),
-    (0x041A0301, '\u{00040C}'),
-    (0x0074030C, '\u{000165}'),
-    (0x00DC0300, '\u{0001DB}'),
-    (0x00780308, '\u{001E8D}'),
-    (0x00DC0304, '\u{0001D5}'),
-    (0x00610302, '\u{0000E2}'),
-    (0x005A0302, '\u{001E90}'),
-    (0x0933093C, '\u{000934}'),
-    (0x004F031B, '\u{0001A0}'),
-    (0x00520311, '\u{000212}'),
-    (0x006E0303, '\u{0000F1}'),
-    (0x0045030F, '\u{000204}'),
-    (0x01AF0309, '\u{001EEC}'),
-    (0x00450304, '\u{000112}'),
-    (0x1F210301, '\u{001F25}'),
-    (0x022F0304, '\u{000231}'),
-    (0x03990306, '\u{001FD8}'),
-    (0x004E0331, '\u{001E48}'),
-    (0x1F380300, '\u{001F3A}'),
-    (0x00490306, '\u{00012C}'),
-    (0x00690306, '\u{00012D}'),
-    (0x1F060345, '\u{001F86}'),
-    (0x00490301, '\u{0000CD}'),
-    (0x00570300, '\u{001E80}'),
-    (0x30F03099, '\u{0030F8}'),
-    (0x0053030C, '\u{000160}'),
-    (0x00490300, '\u{0000CC}'),
-    (0x30723099, '\u{003073}'),
-    (0x1F280300, '\u{001F2A}'),
-    (0x00480307, '\u{001E22}'),
-    (0x01A00309, '\u{001EDE}'),
-    (0x01EB0304, '\u{0001ED}'),
-    (0x1E630307, '\u{001E69}'),
-    (0x006F0323, '\u{001ECD}'),
-    (0x00410303, '\u{0000C3}'),
-    (0x03910345, '\u{001FBC}'),
-    (0x00410328, '\u{000104}'),
-    (0x00680307, '\u{001E23}'),
-    (0x006E0331, '\u{001E49}'),
-    (0x0DDC0DCA, '\u{000DDD}'),
-    (0x00580308, '\u{001E8C}'),
-    (0x00410301, '\u{0000C1}'),
-    (0x30C43099, '\u{0030C5}'),
-    (0x00420323, '\u{001E04}'),
-    (0x00730302, '\u{00015D}'),
-];
-pub(crate) fn composition_table_astral(c1: char, c2: char) -> Option<char> {
-    match (c1, c2) {
-        ('\u{105D2}', '\u{0307}') => Some('\u{105C9}'),
-        ('\u{105DA}', '\u{0307}') => Some('\u{105E4}'),
-        ('\u{11099}', '\u{110BA}') => Some('\u{1109A}'),
-        ('\u{1109B}', '\u{110BA}') => Some('\u{1109C}'),
-        ('\u{110A5}', '\u{110BA}') => Some('\u{110AB}'),
-        ('\u{11131}', '\u{11127}') => Some('\u{1112E}'),
-        ('\u{11132}', '\u{11127}') => Some('\u{1112F}'),
-        ('\u{11347}', '\u{1133E}') => Some('\u{1134B}'),
-        ('\u{11347}', '\u{11357}') => Some('\u{1134C}'),
-        ('\u{11382}', '\u{113C9}') => Some('\u{11383}'),
-        ('\u{11384}', '\u{113BB}') => Some('\u{11385}'),
-        ('\u{1138B}', '\u{113C2}') => Some('\u{1138E}'),
-        ('\u{11390}', '\u{113C9}') => Some('\u{11391}'),
-        ('\u{113C2}', '\u{113B8}') => Some('\u{113C7}'),
-        ('\u{113C2}', '\u{113C2}') => Some('\u{113C5}'),
-        ('\u{113C2}', '\u{113C9}') => Some('\u{113C8}'),
-        ('\u{114B9}', '\u{114B0}') => Some('\u{114BC}'),
-        ('\u{114B9}', '\u{114BA}') => Some('\u{114BB}'),
-        ('\u{114B9}', '\u{114BD}') => Some('\u{114BE}'),
-        ('\u{115B8}', '\u{115AF}') => Some('\u{115BA}'),
-        ('\u{115B9}', '\u{115AF}') => Some('\u{115BB}'),
-        ('\u{11935}', '\u{11930}') => Some('\u{11938}'),
-        ('\u{1611E}', '\u{1611E}') => Some('\u{16121}'),
-        ('\u{1611E}', '\u{1611F}') => Some('\u{16123}'),
-        ('\u{1611E}', '\u{16120}') => Some('\u{16125}'),
-        ('\u{1611E}', '\u{16129}') => Some('\u{16122}'),
-        ('\u{16121}', '\u{1611F}') => Some('\u{16126}'),
-        ('\u{16121}', '\u{16120}') => Some('\u{16128}'),
-        ('\u{16122}', '\u{1611F}') => Some('\u{16127}'),
-        ('\u{16129}', '\u{1611F}') => Some('\u{16124}'),
-        ('\u{16D63}', '\u{16D67}') => Some('\u{16D69}'),
-        ('\u{16D67}', '\u{16D67}') => Some('\u{16D68}'),
-        ('\u{16D69}', '\u{16D67}') => Some('\u{16D6A}'),
-        _ => None,
-    }
-}
-pub(crate) const CANONICAL_DECOMPOSED_CHARS: &[char] = &[
-    '\u{0041}',
-    '\u{0300}',
-    '\u{0041}',
-    '\u{0301}',
-    '\u{0041}',
-    '\u{0302}',
-    '\u{0041}',
-    '\u{0303}',
-    '\u{0041}',
-    '\u{0308}',
-    '\u{0041}',
-    '\u{030A}',
-    '\u{0043}',
-    '\u{0327}',
-    '\u{0045}',
-    '\u{0300}',
-    '\u{0045}',
-    '\u{0301}',
-    '\u{0045}',
-    '\u{0302}',
-    '\u{0045}',
-    '\u{0308}',
-    '\u{0049}',
-    '\u{0300}',
-    '\u{0049}',
-    '\u{0301}',
-    '\u{0049}',
-    '\u{0302}',
-    '\u{0049}',
-    '\u{0308}',
-    '\u{004E}',
-    '\u{0303}',
-    '\u{004F}',
-    '\u{0300}',
-    '\u{004F}',
-    '\u{0301}',
-    '\u{004F}',
-    '\u{0302}',
-    '\u{004F}',
-    '\u{0303}',
-    '\u{004F}',
-    '\u{0308}',
-    '\u{0055}',
-    '\u{0300}',
-    '\u{0055}',
-    '\u{0301}',
-    '\u{0055}',
-    '\u{0302}',
-    '\u{0055}',
-    '\u{0308}',
-    '\u{0059}',
-    '\u{0301}',
-    '\u{0061}',
-    '\u{0300}',
-    '\u{0061}',
-    '\u{0301}',
-    '\u{0061}',
-    '\u{0302}',
-    '\u{0061}',
-    '\u{0303}',
-    '\u{0061}',
-    '\u{0308}',
-    '\u{0061}',
-    '\u{030A}',
-    '\u{0063}',
-    '\u{0327}',
-    '\u{0065}',
-    '\u{0300}',
-    '\u{0065}',
-    '\u{0301}',
-    '\u{0065}',
-    '\u{0302}',
-    '\u{0065}',
-    '\u{0308}',
-    '\u{0069}',
-    '\u{0300}',
-    '\u{0069}',
-    '\u{0301}',
-    '\u{0069}',
-    '\u{0302}',
-    '\u{0069}',
-    '\u{0308}',
-    '\u{006E}',
-    '\u{0303}',
-    '\u{006F}',
-    '\u{0300}',
-    '\u{006F}',
-    '\u{0301}',
-    '\u{006F}',
-    '\u{0302}',
-    '\u{006F}',
-    '\u{0303}',
-    '\u{006F}',
-    '\u{0308}',
-    '\u{0075}',
-    '\u{0300}',
-    '\u{0075}',
-    '\u{0301}',
-    '\u{0075}',
-    '\u{0302}',
-    '\u{0075}',
-    '\u{0308}',
-    '\u{0079}',
-    '\u{0301}',
-    '\u{0079}',
-    '\u{0308}',
-    '\u{0041}',
-    '\u{0304}',
-    '\u{0061}',
-    '\u{0304}',
-    '\u{0041}',
-    '\u{0306}',
-    '\u{0061}',
-    '\u{0306}',
-    '\u{0041}',
-    '\u{0328}',
-    '\u{0061}',
-    '\u{0328}',
-    '\u{0043}',
-    '\u{0301}',
-    '\u{0063}',
-    '\u{0301}',
-    '\u{0043}',
-    '\u{0302}',
-    '\u{0063}',
-    '\u{0302}',
-    '\u{0043}',
-    '\u{0307}',
-    '\u{0063}',
-    '\u{0307}',
-    '\u{0043}',
-    '\u{030C}',
-    '\u{0063}',
-    '\u{030C}',
-    '\u{0044}',
-    '\u{030C}',
-    '\u{0064}',
-    '\u{030C}',
-    '\u{0045}',
-    '\u{0304}',
-    '\u{0065}',
-    '\u{0304}',
-    '\u{0045}',
-    '\u{0306}',
-    '\u{0065}',
-    '\u{0306}',
-    '\u{0045}',
-    '\u{0307}',
-    '\u{0065}',
-    '\u{0307}',
-    '\u{0045}',
-    '\u{0328}',
-    '\u{0065}',
-    '\u{0328}',
-    '\u{0045}',
-    '\u{030C}',
-    '\u{0065}',
-    '\u{030C}',
-    '\u{0047}',
-    '\u{0302}',
-    '\u{0067}',
-    '\u{0302}',
-    '\u{0047}',
-    '\u{0306}',
-    '\u{0067}',
-    '\u{0306}',
-    '\u{0047}',
-    '\u{0307}',
-    '\u{0067}',
-    '\u{0307}',
-    '\u{0047}',
-    '\u{0327}',
-    '\u{0067}',
-    '\u{0327}',
-    '\u{0048}',
-    '\u{0302}',
-    '\u{0068}',
-    '\u{0302}',
-    '\u{0049}',
-    '\u{0303}',
-    '\u{0069}',
-    '\u{0303}',
-    '\u{0049}',
-    '\u{0304}',
-    '\u{0069}',
-    '\u{0304}',
-    '\u{0049}',
-    '\u{0306}',
-    '\u{0069}',
-    '\u{0306}',
-    '\u{0049}',
-    '\u{0328}',
-    '\u{0069}',
-    '\u{0328}',
-    '\u{0049}',
-    '\u{0307}',
-    '\u{004A}',
-    '\u{0302}',
-    '\u{006A}',
-    '\u{0302}',
-    '\u{004B}',
-    '\u{0327}',
-    '\u{006B}',
-    '\u{0327}',
-    '\u{004C}',
-    '\u{0301}',
-    '\u{006C}',
-    '\u{0301}',
-    '\u{004C}',
-    '\u{0327}',
-    '\u{006C}',
-    '\u{0327}',
-    '\u{004C}',
-    '\u{030C}',
-    '\u{006C}',
-    '\u{030C}',
-    '\u{004E}',
-    '\u{0301}',
-    '\u{006E}',
-    '\u{0301}',
-    '\u{004E}',
-    '\u{0327}',
-    '\u{006E}',
-    '\u{0327}',
-    '\u{004E}',
-    '\u{030C}',
-    '\u{006E}',
-    '\u{030C}',
-    '\u{004F}',
-    '\u{0304}',
-    '\u{006F}',
-    '\u{0304}',
-    '\u{004F}',
-    '\u{0306}',
-    '\u{006F}',
-    '\u{0306}',
-    '\u{004F}',
-    '\u{030B}',
-    '\u{006F}',
-    '\u{030B}',
-    '\u{0052}',
-    '\u{0301}',
-    '\u{0072}',
-    '\u{0301}',
-    '\u{0052}',
-    '\u{0327}',
-    '\u{0072}',
-    '\u{0327}',
-    '\u{0052}',
-    '\u{030C}',
-    '\u{0072}',
-    '\u{030C}',
-    '\u{0053}',
-    '\u{0301}',
-    '\u{0073}',
-    '\u{0301}',
-    '\u{0053}',
-    '\u{0302}',
-    '\u{0073}',
-    '\u{0302}',
-    '\u{0053}',
-    '\u{0327}',
-    '\u{0073}',
-    '\u{0327}',
-    '\u{0053}',
-    '\u{030C}',
-    '\u{0073}',
-    '\u{030C}',
-    '\u{0054}',
-    '\u{0327}',
-    '\u{0074}',
-    '\u{0327}',
-    '\u{0054}',
-    '\u{030C}',
-    '\u{0074}',
-    '\u{030C}',
-    '\u{0055}',
-    '\u{0303}',
-    '\u{0075}',
-    '\u{0303}',
-    '\u{0055}',
-    '\u{0304}',
-    '\u{0075}',
-    '\u{0304}',
-    '\u{0055}',
-    '\u{0306}',
-    '\u{0075}',
-    '\u{0306}',
-    '\u{0055}',
-    '\u{030A}',
-    '\u{0075}',
-    '\u{030A}',
-    '\u{0055}',
-    '\u{030B}',
-    '\u{0075}',
-    '\u{030B}',
-    '\u{0055}',
-    '\u{0328}',
-    '\u{0075}',
-    '\u{0328}',
-    '\u{0057}',
-    '\u{0302}',
-    '\u{0077}',
-    '\u{0302}',
-    '\u{0059}',
-    '\u{0302}',
-    '\u{0079}',
-    '\u{0302}',
-    '\u{0059}',
-    '\u{0308}',
-    '\u{005A}',
-    '\u{0301}',
-    '\u{007A}',
-    '\u{0301}',
-    '\u{005A}',
-    '\u{0307}',
-    '\u{007A}',
-    '\u{0307}',
-    '\u{005A}',
-    '\u{030C}',
-    '\u{007A}',
-    '\u{030C}',
-    '\u{004F}',
-    '\u{031B}',
-    '\u{006F}',
-    '\u{031B}',
-    '\u{0055}',
-    '\u{031B}',
-    '\u{0075}',
-    '\u{031B}',
-    '\u{0041}',
-    '\u{030C}',
-    '\u{0061}',
-    '\u{030C}',
-    '\u{0049}',
-    '\u{030C}',
-    '\u{0069}',
-    '\u{030C}',
-    '\u{004F}',
-    '\u{030C}',
-    '\u{006F}',
-    '\u{030C}',
-    '\u{0055}',
-    '\u{030C}',
-    '\u{0075}',
-    '\u{030C}',
-    '\u{0055}',
-    '\u{0308}',
-    '\u{0304}',
-    '\u{0075}',
-    '\u{0308}',
-    '\u{0304}',
-    '\u{0055}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{0075}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{0055}',
-    '\u{0308}',
-    '\u{030C}',
-    '\u{0075}',
-    '\u{0308}',
-    '\u{030C}',
-    '\u{0055}',
-    '\u{0308}',
-    '\u{0300}',
-    '\u{0075}',
-    '\u{0308}',
-    '\u{0300}',
-    '\u{0041}',
-    '\u{0308}',
-    '\u{0304}',
-    '\u{0061}',
-    '\u{0308}',
-    '\u{0304}',
-    '\u{0041}',
-    '\u{0307}',
-    '\u{0304}',
-    '\u{0061}',
-    '\u{0307}',
-    '\u{0304}',
-    '\u{00C6}',
-    '\u{0304}',
-    '\u{00E6}',
-    '\u{0304}',
-    '\u{0047}',
-    '\u{030C}',
-    '\u{0067}',
-    '\u{030C}',
-    '\u{004B}',
-    '\u{030C}',
-    '\u{006B}',
-    '\u{030C}',
-    '\u{004F}',
-    '\u{0328}',
-    '\u{006F}',
-    '\u{0328}',
-    '\u{004F}',
-    '\u{0328}',
-    '\u{0304}',
-    '\u{006F}',
-    '\u{0328}',
-    '\u{0304}',
-    '\u{01B7}',
-    '\u{030C}',
-    '\u{0292}',
-    '\u{030C}',
-    '\u{006A}',
-    '\u{030C}',
-    '\u{0047}',
-    '\u{0301}',
-    '\u{0067}',
-    '\u{0301}',
-    '\u{004E}',
-    '\u{0300}',
-    '\u{006E}',
-    '\u{0300}',
-    '\u{0041}',
-    '\u{030A}',
-    '\u{0301}',
-    '\u{0061}',
-    '\u{030A}',
-    '\u{0301}',
-    '\u{00C6}',
-    '\u{0301}',
-    '\u{00E6}',
-    '\u{0301}',
-    '\u{00D8}',
-    '\u{0301}',
-    '\u{00F8}',
-    '\u{0301}',
-    '\u{0041}',
-    '\u{030F}',
-    '\u{0061}',
-    '\u{030F}',
-    '\u{0041}',
-    '\u{0311}',
-    '\u{0061}',
-    '\u{0311}',
-    '\u{0045}',
-    '\u{030F}',
-    '\u{0065}',
-    '\u{030F}',
-    '\u{0045}',
-    '\u{0311}',
-    '\u{0065}',
-    '\u{0311}',
-    '\u{0049}',
-    '\u{030F}',
-    '\u{0069}',
-    '\u{030F}',
-    '\u{0049}',
-    '\u{0311}',
-    '\u{0069}',
-    '\u{0311}',
-    '\u{004F}',
-    '\u{030F}',
-    '\u{006F}',
-    '\u{030F}',
-    '\u{004F}',
-    '\u{0311}',
-    '\u{006F}',
-    '\u{0311}',
-    '\u{0052}',
-    '\u{030F}',
-    '\u{0072}',
-    '\u{030F}',
-    '\u{0052}',
-    '\u{0311}',
-    '\u{0072}',
-    '\u{0311}',
-    '\u{0055}',
-    '\u{030F}',
-    '\u{0075}',
-    '\u{030F}',
-    '\u{0055}',
-    '\u{0311}',
-    '\u{0075}',
-    '\u{0311}',
-    '\u{0053}',
-    '\u{0326}',
-    '\u{0073}',
-    '\u{0326}',
-    '\u{0054}',
-    '\u{0326}',
-    '\u{0074}',
-    '\u{0326}',
-    '\u{0048}',
-    '\u{030C}',
-    '\u{0068}',
-    '\u{030C}',
-    '\u{0041}',
-    '\u{0307}',
-    '\u{0061}',
-    '\u{0307}',
-    '\u{0045}',
-    '\u{0327}',
-    '\u{0065}',
-    '\u{0327}',
-    '\u{004F}',
-    '\u{0308}',
-    '\u{0304}',
-    '\u{006F}',
-    '\u{0308}',
-    '\u{0304}',
-    '\u{004F}',
-    '\u{0303}',
-    '\u{0304}',
-    '\u{006F}',
-    '\u{0303}',
-    '\u{0304}',
-    '\u{004F}',
-    '\u{0307}',
-    '\u{006F}',
-    '\u{0307}',
-    '\u{004F}',
-    '\u{0307}',
-    '\u{0304}',
-    '\u{006F}',
-    '\u{0307}',
-    '\u{0304}',
-    '\u{0059}',
-    '\u{0304}',
-    '\u{0079}',
-    '\u{0304}',
-    '\u{0300}',
-    '\u{0301}',
-    '\u{0313}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{02B9}',
-    '\u{003B}',
-    '\u{00A8}',
-    '\u{0301}',
-    '\u{0391}',
-    '\u{0301}',
-    '\u{00B7}',
-    '\u{0395}',
-    '\u{0301}',
-    '\u{0397}',
-    '\u{0301}',
-    '\u{0399}',
-    '\u{0301}',
-    '\u{039F}',
-    '\u{0301}',
-    '\u{03A5}',
-    '\u{0301}',
-    '\u{03A9}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{0399}',
-    '\u{0308}',
-    '\u{03A5}',
-    '\u{0308}',
-    '\u{03B1}',
-    '\u{0301}',
-    '\u{03B5}',
-    '\u{0301}',
-    '\u{03B7}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0301}',
-    '\u{03C5}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0308}',
-    '\u{03C5}',
-    '\u{0308}',
-    '\u{03BF}',
-    '\u{0301}',
-    '\u{03C5}',
-    '\u{0301}',
-    '\u{03C9}',
-    '\u{0301}',
-    '\u{03D2}',
-    '\u{0301}',
-    '\u{03D2}',
-    '\u{0308}',
-    '\u{0415}',
-    '\u{0300}',
-    '\u{0415}',
-    '\u{0308}',
-    '\u{0413}',
-    '\u{0301}',
-    '\u{0406}',
-    '\u{0308}',
-    '\u{041A}',
-    '\u{0301}',
-    '\u{0418}',
-    '\u{0300}',
-    '\u{0423}',
-    '\u{0306}',
-    '\u{0418}',
-    '\u{0306}',
-    '\u{0438}',
-    '\u{0306}',
-    '\u{0435}',
-    '\u{0300}',
-    '\u{0435}',
-    '\u{0308}',
-    '\u{0433}',
-    '\u{0301}',
-    '\u{0456}',
-    '\u{0308}',
-    '\u{043A}',
-    '\u{0301}',
-    '\u{0438}',
-    '\u{0300}',
-    '\u{0443}',
-    '\u{0306}',
-    '\u{0474}',
-    '\u{030F}',
-    '\u{0475}',
-    '\u{030F}',
-    '\u{0416}',
-    '\u{0306}',
-    '\u{0436}',
-    '\u{0306}',
-    '\u{0410}',
-    '\u{0306}',
-    '\u{0430}',
-    '\u{0306}',
-    '\u{0410}',
-    '\u{0308}',
-    '\u{0430}',
-    '\u{0308}',
-    '\u{0415}',
-    '\u{0306}',
-    '\u{0435}',
-    '\u{0306}',
-    '\u{04D8}',
-    '\u{0308}',
-    '\u{04D9}',
-    '\u{0308}',
-    '\u{0416}',
-    '\u{0308}',
-    '\u{0436}',
-    '\u{0308}',
-    '\u{0417}',
-    '\u{0308}',
-    '\u{0437}',
-    '\u{0308}',
-    '\u{0418}',
-    '\u{0304}',
-    '\u{0438}',
-    '\u{0304}',
-    '\u{0418}',
-    '\u{0308}',
-    '\u{0438}',
-    '\u{0308}',
-    '\u{041E}',
-    '\u{0308}',
-    '\u{043E}',
-    '\u{0308}',
-    '\u{04E8}',
-    '\u{0308}',
-    '\u{04E9}',
-    '\u{0308}',
-    '\u{042D}',
-    '\u{0308}',
-    '\u{044D}',
-    '\u{0308}',
-    '\u{0423}',
-    '\u{0304}',
-    '\u{0443}',
-    '\u{0304}',
-    '\u{0423}',
-    '\u{0308}',
-    '\u{0443}',
-    '\u{0308}',
-    '\u{0423}',
-    '\u{030B}',
-    '\u{0443}',
-    '\u{030B}',
-    '\u{0427}',
-    '\u{0308}',
-    '\u{0447}',
-    '\u{0308}',
-    '\u{042B}',
-    '\u{0308}',
-    '\u{044B}',
-    '\u{0308}',
-    '\u{0627}',
-    '\u{0653}',
-    '\u{0627}',
-    '\u{0654}',
-    '\u{0648}',
-    '\u{0654}',
-    '\u{0627}',
-    '\u{0655}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06D5}',
-    '\u{0654}',
-    '\u{06C1}',
-    '\u{0654}',
-    '\u{06D2}',
-    '\u{0654}',
-    '\u{0928}',
-    '\u{093C}',
-    '\u{0930}',
-    '\u{093C}',
-    '\u{0933}',
-    '\u{093C}',
-    '\u{0915}',
-    '\u{093C}',
-    '\u{0916}',
-    '\u{093C}',
-    '\u{0917}',
-    '\u{093C}',
-    '\u{091C}',
-    '\u{093C}',
-    '\u{0921}',
-    '\u{093C}',
-    '\u{0922}',
-    '\u{093C}',
-    '\u{092B}',
-    '\u{093C}',
-    '\u{092F}',
-    '\u{093C}',
-    '\u{09C7}',
-    '\u{09BE}',
-    '\u{09C7}',
-    '\u{09D7}',
-    '\u{09A1}',
-    '\u{09BC}',
-    '\u{09A2}',
-    '\u{09BC}',
-    '\u{09AF}',
-    '\u{09BC}',
-    '\u{0A32}',
-    '\u{0A3C}',
-    '\u{0A38}',
-    '\u{0A3C}',
-    '\u{0A16}',
-    '\u{0A3C}',
-    '\u{0A17}',
-    '\u{0A3C}',
-    '\u{0A1C}',
-    '\u{0A3C}',
-    '\u{0A2B}',
-    '\u{0A3C}',
-    '\u{0B47}',
-    '\u{0B56}',
-    '\u{0B47}',
-    '\u{0B3E}',
-    '\u{0B47}',
-    '\u{0B57}',
-    '\u{0B21}',
-    '\u{0B3C}',
-    '\u{0B22}',
-    '\u{0B3C}',
-    '\u{0B92}',
-    '\u{0BD7}',
-    '\u{0BC6}',
-    '\u{0BBE}',
-    '\u{0BC7}',
-    '\u{0BBE}',
-    '\u{0BC6}',
-    '\u{0BD7}',
-    '\u{0C46}',
-    '\u{0C56}',
-    '\u{0CBF}',
-    '\u{0CD5}',
-    '\u{0CC6}',
-    '\u{0CD5}',
-    '\u{0CC6}',
-    '\u{0CD6}',
-    '\u{0CC6}',
-    '\u{0CC2}',
-    '\u{0CC6}',
-    '\u{0CC2}',
-    '\u{0CD5}',
-    '\u{0D46}',
-    '\u{0D3E}',
-    '\u{0D47}',
-    '\u{0D3E}',
-    '\u{0D46}',
-    '\u{0D57}',
-    '\u{0DD9}',
-    '\u{0DCA}',
-    '\u{0DD9}',
-    '\u{0DCF}',
-    '\u{0DD9}',
-    '\u{0DCF}',
-    '\u{0DCA}',
-    '\u{0DD9}',
-    '\u{0DDF}',
-    '\u{0F42}',
-    '\u{0FB7}',
-    '\u{0F4C}',
-    '\u{0FB7}',
-    '\u{0F51}',
-    '\u{0FB7}',
-    '\u{0F56}',
-    '\u{0FB7}',
-    '\u{0F5B}',
-    '\u{0FB7}',
-    '\u{0F40}',
-    '\u{0FB5}',
-    '\u{0F71}',
-    '\u{0F72}',
-    '\u{0F71}',
-    '\u{0F74}',
-    '\u{0FB2}',
-    '\u{0F80}',
-    '\u{0FB3}',
-    '\u{0F80}',
-    '\u{0F71}',
-    '\u{0F80}',
-    '\u{0F92}',
-    '\u{0FB7}',
-    '\u{0F9C}',
-    '\u{0FB7}',
-    '\u{0FA1}',
-    '\u{0FB7}',
-    '\u{0FA6}',
-    '\u{0FB7}',
-    '\u{0FAB}',
-    '\u{0FB7}',
-    '\u{0F90}',
-    '\u{0FB5}',
-    '\u{1025}',
-    '\u{102E}',
-    '\u{1B05}',
-    '\u{1B35}',
-    '\u{1B07}',
-    '\u{1B35}',
-    '\u{1B09}',
-    '\u{1B35}',
-    '\u{1B0B}',
-    '\u{1B35}',
-    '\u{1B0D}',
-    '\u{1B35}',
-    '\u{1B11}',
-    '\u{1B35}',
-    '\u{1B3A}',
-    '\u{1B35}',
-    '\u{1B3C}',
-    '\u{1B35}',
-    '\u{1B3E}',
-    '\u{1B35}',
-    '\u{1B3F}',
-    '\u{1B35}',
-    '\u{1B42}',
-    '\u{1B35}',
-    '\u{0041}',
-    '\u{0325}',
-    '\u{0061}',
-    '\u{0325}',
-    '\u{0042}',
-    '\u{0307}',
-    '\u{0062}',
-    '\u{0307}',
-    '\u{0042}',
-    '\u{0323}',
-    '\u{0062}',
-    '\u{0323}',
-    '\u{0042}',
-    '\u{0331}',
-    '\u{0062}',
-    '\u{0331}',
-    '\u{0043}',
-    '\u{0327}',
-    '\u{0301}',
-    '\u{0063}',
-    '\u{0327}',
-    '\u{0301}',
-    '\u{0044}',
-    '\u{0307}',
-    '\u{0064}',
-    '\u{0307}',
-    '\u{0044}',
-    '\u{0323}',
-    '\u{0064}',
-    '\u{0323}',
-    '\u{0044}',
-    '\u{0331}',
-    '\u{0064}',
-    '\u{0331}',
-    '\u{0044}',
-    '\u{0327}',
-    '\u{0064}',
-    '\u{0327}',
-    '\u{0044}',
-    '\u{032D}',
-    '\u{0064}',
-    '\u{032D}',
-    '\u{0045}',
-    '\u{0304}',
-    '\u{0300}',
-    '\u{0065}',
-    '\u{0304}',
-    '\u{0300}',
-    '\u{0045}',
-    '\u{0304}',
-    '\u{0301}',
-    '\u{0065}',
-    '\u{0304}',
-    '\u{0301}',
-    '\u{0045}',
-    '\u{032D}',
-    '\u{0065}',
-    '\u{032D}',
-    '\u{0045}',
-    '\u{0330}',
-    '\u{0065}',
-    '\u{0330}',
-    '\u{0045}',
-    '\u{0327}',
-    '\u{0306}',
-    '\u{0065}',
-    '\u{0327}',
-    '\u{0306}',
-    '\u{0046}',
-    '\u{0307}',
-    '\u{0066}',
-    '\u{0307}',
-    '\u{0047}',
-    '\u{0304}',
-    '\u{0067}',
-    '\u{0304}',
-    '\u{0048}',
-    '\u{0307}',
-    '\u{0068}',
-    '\u{0307}',
-    '\u{0048}',
-    '\u{0323}',
-    '\u{0068}',
-    '\u{0323}',
-    '\u{0048}',
-    '\u{0308}',
-    '\u{0068}',
-    '\u{0308}',
-    '\u{0048}',
-    '\u{0327}',
-    '\u{0068}',
-    '\u{0327}',
-    '\u{0048}',
-    '\u{032E}',
-    '\u{0068}',
-    '\u{032E}',
-    '\u{0049}',
-    '\u{0330}',
-    '\u{0069}',
-    '\u{0330}',
-    '\u{0049}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{0069}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{004B}',
-    '\u{0301}',
-    '\u{006B}',
-    '\u{0301}',
-    '\u{004B}',
-    '\u{0323}',
-    '\u{006B}',
-    '\u{0323}',
-    '\u{004B}',
-    '\u{0331}',
-    '\u{006B}',
-    '\u{0331}',
-    '\u{004C}',
-    '\u{0323}',
-    '\u{006C}',
-    '\u{0323}',
-    '\u{004C}',
-    '\u{0323}',
-    '\u{0304}',
-    '\u{006C}',
-    '\u{0323}',
-    '\u{0304}',
-    '\u{004C}',
-    '\u{0331}',
-    '\u{006C}',
-    '\u{0331}',
-    '\u{004C}',
-    '\u{032D}',
-    '\u{006C}',
-    '\u{032D}',
-    '\u{004D}',
-    '\u{0301}',
-    '\u{006D}',
-    '\u{0301}',
-    '\u{004D}',
-    '\u{0307}',
-    '\u{006D}',
-    '\u{0307}',
-    '\u{004D}',
-    '\u{0323}',
-    '\u{006D}',
-    '\u{0323}',
-    '\u{004E}',
-    '\u{0307}',
-    '\u{006E}',
-    '\u{0307}',
-    '\u{004E}',
-    '\u{0323}',
-    '\u{006E}',
-    '\u{0323}',
-    '\u{004E}',
-    '\u{0331}',
-    '\u{006E}',
-    '\u{0331}',
-    '\u{004E}',
-    '\u{032D}',
-    '\u{006E}',
-    '\u{032D}',
-    '\u{004F}',
-    '\u{0303}',
-    '\u{0301}',
-    '\u{006F}',
-    '\u{0303}',
-    '\u{0301}',
-    '\u{004F}',
-    '\u{0303}',
-    '\u{0308}',
-    '\u{006F}',
-    '\u{0303}',
-    '\u{0308}',
-    '\u{004F}',
-    '\u{0304}',
-    '\u{0300}',
-    '\u{006F}',
-    '\u{0304}',
-    '\u{0300}',
-    '\u{004F}',
-    '\u{0304}',
-    '\u{0301}',
-    '\u{006F}',
-    '\u{0304}',
-    '\u{0301}',
-    '\u{0050}',
-    '\u{0301}',
-    '\u{0070}',
-    '\u{0301}',
-    '\u{0050}',
-    '\u{0307}',
-    '\u{0070}',
-    '\u{0307}',
-    '\u{0052}',
-    '\u{0307}',
-    '\u{0072}',
-    '\u{0307}',
-    '\u{0052}',
-    '\u{0323}',
-    '\u{0072}',
-    '\u{0323}',
-    '\u{0052}',
-    '\u{0323}',
-    '\u{0304}',
-    '\u{0072}',
-    '\u{0323}',
-    '\u{0304}',
-    '\u{0052}',
-    '\u{0331}',
-    '\u{0072}',
-    '\u{0331}',
-    '\u{0053}',
-    '\u{0307}',
-    '\u{0073}',
-    '\u{0307}',
-    '\u{0053}',
-    '\u{0323}',
-    '\u{0073}',
-    '\u{0323}',
-    '\u{0053}',
-    '\u{0301}',
-    '\u{0307}',
-    '\u{0073}',
-    '\u{0301}',
-    '\u{0307}',
-    '\u{0053}',
-    '\u{030C}',
-    '\u{0307}',
-    '\u{0073}',
-    '\u{030C}',
-    '\u{0307}',
-    '\u{0053}',
-    '\u{0323}',
-    '\u{0307}',
-    '\u{0073}',
-    '\u{0323}',
-    '\u{0307}',
-    '\u{0054}',
-    '\u{0307}',
-    '\u{0074}',
-    '\u{0307}',
-    '\u{0054}',
-    '\u{0323}',
-    '\u{0074}',
-    '\u{0323}',
-    '\u{0054}',
-    '\u{0331}',
-    '\u{0074}',
-    '\u{0331}',
-    '\u{0054}',
-    '\u{032D}',
-    '\u{0074}',
-    '\u{032D}',
-    '\u{0055}',
-    '\u{0324}',
-    '\u{0075}',
-    '\u{0324}',
-    '\u{0055}',
-    '\u{0330}',
-    '\u{0075}',
-    '\u{0330}',
-    '\u{0055}',
-    '\u{032D}',
-    '\u{0075}',
-    '\u{032D}',
-    '\u{0055}',
-    '\u{0303}',
-    '\u{0301}',
-    '\u{0075}',
-    '\u{0303}',
-    '\u{0301}',
-    '\u{0055}',
-    '\u{0304}',
-    '\u{0308}',
-    '\u{0075}',
-    '\u{0304}',
-    '\u{0308}',
-    '\u{0056}',
-    '\u{0303}',
-    '\u{0076}',
-    '\u{0303}',
-    '\u{0056}',
-    '\u{0323}',
-    '\u{0076}',
-    '\u{0323}',
-    '\u{0057}',
-    '\u{0300}',
-    '\u{0077}',
-    '\u{0300}',
-    '\u{0057}',
-    '\u{0301}',
-    '\u{0077}',
-    '\u{0301}',
-    '\u{0057}',
-    '\u{0308}',
-    '\u{0077}',
-    '\u{0308}',
-    '\u{0057}',
-    '\u{0307}',
-    '\u{0077}',
-    '\u{0307}',
-    '\u{0057}',
-    '\u{0323}',
-    '\u{0077}',
-    '\u{0323}',
-    '\u{0058}',
-    '\u{0307}',
-    '\u{0078}',
-    '\u{0307}',
-    '\u{0058}',
-    '\u{0308}',
-    '\u{0078}',
-    '\u{0308}',
-    '\u{0059}',
-    '\u{0307}',
-    '\u{0079}',
-    '\u{0307}',
-    '\u{005A}',
-    '\u{0302}',
-    '\u{007A}',
-    '\u{0302}',
-    '\u{005A}',
-    '\u{0323}',
-    '\u{007A}',
-    '\u{0323}',
-    '\u{005A}',
-    '\u{0331}',
-    '\u{007A}',
-    '\u{0331}',
-    '\u{0068}',
-    '\u{0331}',
-    '\u{0074}',
-    '\u{0308}',
-    '\u{0077}',
-    '\u{030A}',
-    '\u{0079}',
-    '\u{030A}',
-    '\u{017F}',
-    '\u{0307}',
-    '\u{0041}',
-    '\u{0323}',
-    '\u{0061}',
-    '\u{0323}',
-    '\u{0041}',
-    '\u{0309}',
-    '\u{0061}',
-    '\u{0309}',
-    '\u{0041}',
-    '\u{0302}',
-    '\u{0301}',
-    '\u{0061}',
-    '\u{0302}',
-    '\u{0301}',
-    '\u{0041}',
-    '\u{0302}',
-    '\u{0300}',
-    '\u{0061}',
-    '\u{0302}',
-    '\u{0300}',
-    '\u{0041}',
-    '\u{0302}',
-    '\u{0309}',
-    '\u{0061}',
-    '\u{0302}',
-    '\u{0309}',
-    '\u{0041}',
-    '\u{0302}',
-    '\u{0303}',
-    '\u{0061}',
-    '\u{0302}',
-    '\u{0303}',
-    '\u{0041}',
-    '\u{0323}',
-    '\u{0302}',
-    '\u{0061}',
-    '\u{0323}',
-    '\u{0302}',
-    '\u{0041}',
-    '\u{0306}',
-    '\u{0301}',
-    '\u{0061}',
-    '\u{0306}',
-    '\u{0301}',
-    '\u{0041}',
-    '\u{0306}',
-    '\u{0300}',
-    '\u{0061}',
-    '\u{0306}',
-    '\u{0300}',
-    '\u{0041}',
-    '\u{0306}',
-    '\u{0309}',
-    '\u{0061}',
-    '\u{0306}',
-    '\u{0309}',
-    '\u{0041}',
-    '\u{0306}',
-    '\u{0303}',
-    '\u{0061}',
-    '\u{0306}',
-    '\u{0303}',
-    '\u{0041}',
-    '\u{0323}',
-    '\u{0306}',
-    '\u{0061}',
-    '\u{0323}',
-    '\u{0306}',
-    '\u{0045}',
-    '\u{0323}',
-    '\u{0065}',
-    '\u{0323}',
-    '\u{0045}',
-    '\u{0309}',
-    '\u{0065}',
-    '\u{0309}',
-    '\u{0045}',
-    '\u{0303}',
-    '\u{0065}',
-    '\u{0303}',
-    '\u{0045}',
-    '\u{0302}',
-    '\u{0301}',
-    '\u{0065}',
-    '\u{0302}',
-    '\u{0301}',
-    '\u{0045}',
-    '\u{0302}',
-    '\u{0300}',
-    '\u{0065}',
-    '\u{0302}',
-    '\u{0300}',
-    '\u{0045}',
-    '\u{0302}',
-    '\u{0309}',
-    '\u{0065}',
-    '\u{0302}',
-    '\u{0309}',
-    '\u{0045}',
-    '\u{0302}',
-    '\u{0303}',
-    '\u{0065}',
-    '\u{0302}',
-    '\u{0303}',
-    '\u{0045}',
-    '\u{0323}',
-    '\u{0302}',
-    '\u{0065}',
-    '\u{0323}',
-    '\u{0302}',
-    '\u{0049}',
-    '\u{0309}',
-    '\u{0069}',
-    '\u{0309}',
-    '\u{0049}',
-    '\u{0323}',
-    '\u{0069}',
-    '\u{0323}',
-    '\u{004F}',
-    '\u{0323}',
-    '\u{006F}',
-    '\u{0323}',
-    '\u{004F}',
-    '\u{0309}',
-    '\u{006F}',
-    '\u{0309}',
-    '\u{004F}',
-    '\u{0302}',
-    '\u{0301}',
-    '\u{006F}',
-    '\u{0302}',
-    '\u{0301}',
-    '\u{004F}',
-    '\u{0302}',
-    '\u{0300}',
-    '\u{006F}',
-    '\u{0302}',
-    '\u{0300}',
-    '\u{004F}',
-    '\u{0302}',
-    '\u{0309}',
-    '\u{006F}',
-    '\u{0302}',
-    '\u{0309}',
-    '\u{004F}',
-    '\u{0302}',
-    '\u{0303}',
-    '\u{006F}',
-    '\u{0302}',
-    '\u{0303}',
-    '\u{004F}',
-    '\u{0323}',
-    '\u{0302}',
-    '\u{006F}',
-    '\u{0323}',
-    '\u{0302}',
-    '\u{004F}',
-    '\u{031B}',
-    '\u{0301}',
-    '\u{006F}',
-    '\u{031B}',
-    '\u{0301}',
-    '\u{004F}',
-    '\u{031B}',
-    '\u{0300}',
-    '\u{006F}',
-    '\u{031B}',
-    '\u{0300}',
-    '\u{004F}',
-    '\u{031B}',
-    '\u{0309}',
-    '\u{006F}',
-    '\u{031B}',
-    '\u{0309}',
-    '\u{004F}',
-    '\u{031B}',
-    '\u{0303}',
-    '\u{006F}',
-    '\u{031B}',
-    '\u{0303}',
-    '\u{004F}',
-    '\u{031B}',
-    '\u{0323}',
-    '\u{006F}',
-    '\u{031B}',
-    '\u{0323}',
-    '\u{0055}',
-    '\u{0323}',
-    '\u{0075}',
-    '\u{0323}',
-    '\u{0055}',
-    '\u{0309}',
-    '\u{0075}',
-    '\u{0309}',
-    '\u{0055}',
-    '\u{031B}',
-    '\u{0301}',
-    '\u{0075}',
-    '\u{031B}',
-    '\u{0301}',
-    '\u{0055}',
-    '\u{031B}',
-    '\u{0300}',
-    '\u{0075}',
-    '\u{031B}',
-    '\u{0300}',
-    '\u{0055}',
-    '\u{031B}',
-    '\u{0309}',
-    '\u{0075}',
-    '\u{031B}',
-    '\u{0309}',
-    '\u{0055}',
-    '\u{031B}',
-    '\u{0303}',
-    '\u{0075}',
-    '\u{031B}',
-    '\u{0303}',
-    '\u{0055}',
-    '\u{031B}',
-    '\u{0323}',
-    '\u{0075}',
-    '\u{031B}',
-    '\u{0323}',
-    '\u{0059}',
-    '\u{0300}',
-    '\u{0079}',
-    '\u{0300}',
-    '\u{0059}',
-    '\u{0323}',
-    '\u{0079}',
-    '\u{0323}',
-    '\u{0059}',
-    '\u{0309}',
-    '\u{0079}',
-    '\u{0309}',
-    '\u{0059}',
-    '\u{0303}',
-    '\u{0079}',
-    '\u{0303}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03B5}',
-    '\u{0313}',
-    '\u{03B5}',
-    '\u{0314}',
-    '\u{03B5}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03B5}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03B5}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03B5}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0395}',
-    '\u{0313}',
-    '\u{0395}',
-    '\u{0314}',
-    '\u{0395}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0395}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0395}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0395}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03B9}',
-    '\u{0313}',
-    '\u{03B9}',
-    '\u{0314}',
-    '\u{03B9}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03B9}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03B9}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{03B9}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0399}',
-    '\u{0313}',
-    '\u{0399}',
-    '\u{0314}',
-    '\u{0399}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0399}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0399}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0399}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0399}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0399}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03BF}',
-    '\u{0313}',
-    '\u{03BF}',
-    '\u{0314}',
-    '\u{03BF}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03BF}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03BF}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03BF}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{039F}',
-    '\u{0313}',
-    '\u{039F}',
-    '\u{0314}',
-    '\u{039F}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{039F}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{039F}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{039F}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03C5}',
-    '\u{0313}',
-    '\u{03C5}',
-    '\u{0314}',
-    '\u{03C5}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03C5}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03C5}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03C5}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03C5}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{03C5}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03A5}',
-    '\u{0314}',
-    '\u{03A5}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03A5}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03A5}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{03B1}',
-    '\u{0300}',
-    '\u{03B1}',
-    '\u{0301}',
-    '\u{03B5}',
-    '\u{0300}',
-    '\u{03B5}',
-    '\u{0301}',
-    '\u{03B7}',
-    '\u{0300}',
-    '\u{03B7}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0300}',
-    '\u{03B9}',
-    '\u{0301}',
-    '\u{03BF}',
-    '\u{0300}',
-    '\u{03BF}',
-    '\u{0301}',
-    '\u{03C5}',
-    '\u{0300}',
-    '\u{03C5}',
-    '\u{0301}',
-    '\u{03C9}',
-    '\u{0300}',
-    '\u{03C9}',
-    '\u{0301}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{0397}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03A9}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0306}',
-    '\u{03B1}',
-    '\u{0304}',
-    '\u{03B1}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03B1}',
-    '\u{0342}',
-    '\u{03B1}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{0391}',
-    '\u{0306}',
-    '\u{0391}',
-    '\u{0304}',
-    '\u{0391}',
-    '\u{0300}',
-    '\u{0391}',
-    '\u{0301}',
-    '\u{0391}',
-    '\u{0345}',
-    '\u{03B9}',
-    '\u{00A8}',
-    '\u{0342}',
-    '\u{03B7}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03B7}',
-    '\u{0342}',
-    '\u{03B7}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{0395}',
-    '\u{0300}',
-    '\u{0395}',
-    '\u{0301}',
-    '\u{0397}',
-    '\u{0300}',
-    '\u{0397}',
-    '\u{0301}',
-    '\u{0397}',
-    '\u{0345}',
-    '\u{1FBF}',
-    '\u{0300}',
-    '\u{1FBF}',
-    '\u{0301}',
-    '\u{1FBF}',
-    '\u{0342}',
-    '\u{03B9}',
-    '\u{0306}',
-    '\u{03B9}',
-    '\u{0304}',
-    '\u{03B9}',
-    '\u{0308}',
-    '\u{0300}',
-    '\u{03B9}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{03B9}',
-    '\u{0342}',
-    '\u{03B9}',
-    '\u{0308}',
-    '\u{0342}',
-    '\u{0399}',
-    '\u{0306}',
-    '\u{0399}',
-    '\u{0304}',
-    '\u{0399}',
-    '\u{0300}',
-    '\u{0399}',
-    '\u{0301}',
-    '\u{1FFE}',
-    '\u{0300}',
-    '\u{1FFE}',
-    '\u{0301}',
-    '\u{1FFE}',
-    '\u{0342}',
-    '\u{03C5}',
-    '\u{0306}',
-    '\u{03C5}',
-    '\u{0304}',
-    '\u{03C5}',
-    '\u{0308}',
-    '\u{0300}',
-    '\u{03C5}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{03C1}',
-    '\u{0313}',
-    '\u{03C1}',
-    '\u{0314}',
-    '\u{03C5}',
-    '\u{0342}',
-    '\u{03C5}',
-    '\u{0308}',
-    '\u{0342}',
-    '\u{03A5}',
-    '\u{0306}',
-    '\u{03A5}',
-    '\u{0304}',
-    '\u{03A5}',
-    '\u{0300}',
-    '\u{03A5}',
-    '\u{0301}',
-    '\u{03A1}',
-    '\u{0314}',
-    '\u{00A8}',
-    '\u{0300}',
-    '\u{00A8}',
-    '\u{0301}',
-    '\u{0060}',
-    '\u{03C9}',
-    '\u{0300}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0301}',
-    '\u{0345}',
-    '\u{03C9}',
-    '\u{0342}',
-    '\u{03C9}',
-    '\u{0342}',
-    '\u{0345}',
-    '\u{039F}',
-    '\u{0300}',
-    '\u{039F}',
-    '\u{0301}',
-    '\u{03A9}',
-    '\u{0300}',
-    '\u{03A9}',
-    '\u{0301}',
-    '\u{03A9}',
-    '\u{0345}',
-    '\u{00B4}',
-    '\u{2002}',
-    '\u{2003}',
-    '\u{03A9}',
-    '\u{004B}',
-    '\u{0041}',
-    '\u{030A}',
-    '\u{2190}',
-    '\u{0338}',
-    '\u{2192}',
-    '\u{0338}',
-    '\u{2194}',
-    '\u{0338}',
-    '\u{21D0}',
-    '\u{0338}',
-    '\u{21D4}',
-    '\u{0338}',
-    '\u{21D2}',
-    '\u{0338}',
-    '\u{2203}',
-    '\u{0338}',
-    '\u{2208}',
-    '\u{0338}',
-    '\u{220B}',
-    '\u{0338}',
-    '\u{2223}',
-    '\u{0338}',
-    '\u{2225}',
-    '\u{0338}',
-    '\u{223C}',
-    '\u{0338}',
-    '\u{2243}',
-    '\u{0338}',
-    '\u{2245}',
-    '\u{0338}',
-    '\u{2248}',
-    '\u{0338}',
-    '\u{003D}',
-    '\u{0338}',
-    '\u{2261}',
-    '\u{0338}',
-    '\u{224D}',
-    '\u{0338}',
-    '\u{003C}',
-    '\u{0338}',
-    '\u{003E}',
-    '\u{0338}',
-    '\u{2264}',
-    '\u{0338}',
-    '\u{2265}',
-    '\u{0338}',
-    '\u{2272}',
-    '\u{0338}',
-    '\u{2273}',
-    '\u{0338}',
-    '\u{2276}',
-    '\u{0338}',
-    '\u{2277}',
-    '\u{0338}',
-    '\u{227A}',
-    '\u{0338}',
-    '\u{227B}',
-    '\u{0338}',
-    '\u{2282}',
-    '\u{0338}',
-    '\u{2283}',
-    '\u{0338}',
-    '\u{2286}',
-    '\u{0338}',
-    '\u{2287}',
-    '\u{0338}',
-    '\u{22A2}',
-    '\u{0338}',
-    '\u{22A8}',
-    '\u{0338}',
-    '\u{22A9}',
-    '\u{0338}',
-    '\u{22AB}',
-    '\u{0338}',
-    '\u{227C}',
-    '\u{0338}',
-    '\u{227D}',
-    '\u{0338}',
-    '\u{2291}',
-    '\u{0338}',
-    '\u{2292}',
-    '\u{0338}',
-    '\u{22B2}',
-    '\u{0338}',
-    '\u{22B3}',
-    '\u{0338}',
-    '\u{22B4}',
-    '\u{0338}',
-    '\u{22B5}',
-    '\u{0338}',
-    '\u{3008}',
-    '\u{3009}',
-    '\u{2ADD}',
-    '\u{0338}',
-    '\u{304B}',
-    '\u{3099}',
-    '\u{304D}',
-    '\u{3099}',
-    '\u{304F}',
-    '\u{3099}',
-    '\u{3051}',
-    '\u{3099}',
-    '\u{3053}',
-    '\u{3099}',
-    '\u{3055}',
-    '\u{3099}',
-    '\u{3057}',
-    '\u{3099}',
-    '\u{3059}',
-    '\u{3099}',
-    '\u{305B}',
-    '\u{3099}',
-    '\u{305D}',
-    '\u{3099}',
-    '\u{305F}',
-    '\u{3099}',
-    '\u{3061}',
-    '\u{3099}',
-    '\u{3064}',
-    '\u{3099}',
-    '\u{3066}',
-    '\u{3099}',
-    '\u{3068}',
-    '\u{3099}',
-    '\u{306F}',
-    '\u{3099}',
-    '\u{306F}',
-    '\u{309A}',
-    '\u{3072}',
-    '\u{3099}',
-    '\u{3072}',
-    '\u{309A}',
-    '\u{3075}',
-    '\u{3099}',
-    '\u{3075}',
-    '\u{309A}',
-    '\u{3078}',
-    '\u{3099}',
-    '\u{3078}',
-    '\u{309A}',
-    '\u{307B}',
-    '\u{3099}',
-    '\u{307B}',
-    '\u{309A}',
-    '\u{3046}',
-    '\u{3099}',
-    '\u{309D}',
-    '\u{3099}',
-    '\u{30AB}',
-    '\u{3099}',
-    '\u{30AD}',
-    '\u{3099}',
-    '\u{30AF}',
-    '\u{3099}',
-    '\u{30B1}',
-    '\u{3099}',
-    '\u{30B3}',
-    '\u{3099}',
-    '\u{30B5}',
-    '\u{3099}',
-    '\u{30B7}',
-    '\u{3099}',
-    '\u{30B9}',
-    '\u{3099}',
-    '\u{30BB}',
-    '\u{3099}',
-    '\u{30BD}',
-    '\u{3099}',
-    '\u{30BF}',
-    '\u{3099}',
-    '\u{30C1}',
-    '\u{3099}',
-    '\u{30C4}',
-    '\u{3099}',
-    '\u{30C6}',
-    '\u{3099}',
-    '\u{30C8}',
-    '\u{3099}',
-    '\u{30CF}',
-    '\u{3099}',
-    '\u{30CF}',
-    '\u{309A}',
-    '\u{30D2}',
-    '\u{3099}',
-    '\u{30D2}',
-    '\u{309A}',
-    '\u{30D5}',
-    '\u{3099}',
-    '\u{30D5}',
-    '\u{309A}',
-    '\u{30D8}',
-    '\u{3099}',
-    '\u{30D8}',
-    '\u{309A}',
-    '\u{30DB}',
-    '\u{3099}',
-    '\u{30DB}',
-    '\u{309A}',
-    '\u{30A6}',
-    '\u{3099}',
-    '\u{30EF}',
-    '\u{3099}',
-    '\u{30F0}',
-    '\u{3099}',
-    '\u{30F1}',
-    '\u{3099}',
-    '\u{30F2}',
-    '\u{3099}',
-    '\u{30FD}',
-    '\u{3099}',
-    '\u{8C48}',
-    '\u{66F4}',
-    '\u{8ECA}',
-    '\u{8CC8}',
-    '\u{6ED1}',
-    '\u{4E32}',
-    '\u{53E5}',
-    '\u{9F9C}',
-    '\u{9F9C}',
-    '\u{5951}',
-    '\u{91D1}',
-    '\u{5587}',
-    '\u{5948}',
-    '\u{61F6}',
-    '\u{7669}',
-    '\u{7F85}',
-    '\u{863F}',
-    '\u{87BA}',
-    '\u{88F8}',
-    '\u{908F}',
-    '\u{6A02}',
-    '\u{6D1B}',
-    '\u{70D9}',
-    '\u{73DE}',
-    '\u{843D}',
-    '\u{916A}',
-    '\u{99F1}',
-    '\u{4E82}',
-    '\u{5375}',
-    '\u{6B04}',
-    '\u{721B}',
-    '\u{862D}',
-    '\u{9E1E}',
-    '\u{5D50}',
-    '\u{6FEB}',
-    '\u{85CD}',
-    '\u{8964}',
-    '\u{62C9}',
-    '\u{81D8}',
-    '\u{881F}',
-    '\u{5ECA}',
-    '\u{6717}',
-    '\u{6D6A}',
-    '\u{72FC}',
-    '\u{90CE}',
-    '\u{4F86}',
-    '\u{51B7}',
-    '\u{52DE}',
-    '\u{64C4}',
-    '\u{6AD3}',
-    '\u{7210}',
-    '\u{76E7}',
-    '\u{8001}',
-    '\u{8606}',
-    '\u{865C}',
-    '\u{8DEF}',
-    '\u{9732}',
-    '\u{9B6F}',
-    '\u{9DFA}',
-    '\u{788C}',
-    '\u{797F}',
-    '\u{7DA0}',
-    '\u{83C9}',
-    '\u{9304}',
-    '\u{9E7F}',
-    '\u{8AD6}',
-    '\u{58DF}',
-    '\u{5F04}',
-    '\u{7C60}',
-    '\u{807E}',
-    '\u{7262}',
-    '\u{78CA}',
-    '\u{8CC2}',
-    '\u{96F7}',
-    '\u{58D8}',
-    '\u{5C62}',
-    '\u{6A13}',
-    '\u{6DDA}',
-    '\u{6F0F}',
-    '\u{7D2F}',
-    '\u{7E37}',
-    '\u{964B}',
-    '\u{52D2}',
-    '\u{808B}',
-    '\u{51DC}',
-    '\u{51CC}',
-    '\u{7A1C}',
-    '\u{7DBE}',
-    '\u{83F1}',
-    '\u{9675}',
-    '\u{8B80}',
-    '\u{62CF}',
-    '\u{6A02}',
-    '\u{8AFE}',
-    '\u{4E39}',
-    '\u{5BE7}',
-    '\u{6012}',
-    '\u{7387}',
-    '\u{7570}',
-    '\u{5317}',
-    '\u{78FB}',
-    '\u{4FBF}',
-    '\u{5FA9}',
-    '\u{4E0D}',
-    '\u{6CCC}',
-    '\u{6578}',
-    '\u{7D22}',
-    '\u{53C3}',
-    '\u{585E}',
-    '\u{7701}',
-    '\u{8449}',
-    '\u{8AAA}',
-    '\u{6BBA}',
-    '\u{8FB0}',
-    '\u{6C88}',
-    '\u{62FE}',
-    '\u{82E5}',
-    '\u{63A0}',
-    '\u{7565}',
-    '\u{4EAE}',
-    '\u{5169}',
-    '\u{51C9}',
-    '\u{6881}',
-    '\u{7CE7}',
-    '\u{826F}',
-    '\u{8AD2}',
-    '\u{91CF}',
-    '\u{52F5}',
-    '\u{5442}',
-    '\u{5973}',
-    '\u{5EEC}',
-    '\u{65C5}',
-    '\u{6FFE}',
-    '\u{792A}',
-    '\u{95AD}',
-    '\u{9A6A}',
-    '\u{9E97}',
-    '\u{9ECE}',
-    '\u{529B}',
-    '\u{66C6}',
-    '\u{6B77}',
-    '\u{8F62}',
-    '\u{5E74}',
-    '\u{6190}',
-    '\u{6200}',
-    '\u{649A}',
-    '\u{6F23}',
-    '\u{7149}',
-    '\u{7489}',
-    '\u{79CA}',
-    '\u{7DF4}',
-    '\u{806F}',
-    '\u{8F26}',
-    '\u{84EE}',
-    '\u{9023}',
-    '\u{934A}',
-    '\u{5217}',
-    '\u{52A3}',
-    '\u{54BD}',
-    '\u{70C8}',
-    '\u{88C2}',
-    '\u{8AAA}',
-    '\u{5EC9}',
-    '\u{5FF5}',
-    '\u{637B}',
-    '\u{6BAE}',
-    '\u{7C3E}',
-    '\u{7375}',
-    '\u{4EE4}',
-    '\u{56F9}',
-    '\u{5BE7}',
-    '\u{5DBA}',
-    '\u{601C}',
-    '\u{73B2}',
-    '\u{7469}',
-    '\u{7F9A}',
-    '\u{8046}',
-    '\u{9234}',
-    '\u{96F6}',
-    '\u{9748}',
-    '\u{9818}',
-    '\u{4F8B}',
-    '\u{79AE}',
-    '\u{91B4}',
-    '\u{96B8}',
-    '\u{60E1}',
-    '\u{4E86}',
-    '\u{50DA}',
-    '\u{5BEE}',
-    '\u{5C3F}',
-    '\u{6599}',
-    '\u{6A02}',
-    '\u{71CE}',
-    '\u{7642}',
-    '\u{84FC}',
-    '\u{907C}',
-    '\u{9F8D}',
-    '\u{6688}',
-    '\u{962E}',
-    '\u{5289}',
-    '\u{677B}',
-    '\u{67F3}',
-    '\u{6D41}',
-    '\u{6E9C}',
-    '\u{7409}',
-    '\u{7559}',
-    '\u{786B}',
-    '\u{7D10}',
-    '\u{985E}',
-    '\u{516D}',
-    '\u{622E}',
-    '\u{9678}',
-    '\u{502B}',
-    '\u{5D19}',
-    '\u{6DEA}',
-    '\u{8F2A}',
-    '\u{5F8B}',
-    '\u{6144}',
-    '\u{6817}',
-    '\u{7387}',
-    '\u{9686}',
-    '\u{5229}',
-    '\u{540F}',
-    '\u{5C65}',
-    '\u{6613}',
-    '\u{674E}',
-    '\u{68A8}',
-    '\u{6CE5}',
-    '\u{7406}',
-    '\u{75E2}',
-    '\u{7F79}',
-    '\u{88CF}',
-    '\u{88E1}',
-    '\u{91CC}',
-    '\u{96E2}',
-    '\u{533F}',
-    '\u{6EBA}',
-    '\u{541D}',
-    '\u{71D0}',
-    '\u{7498}',
-    '\u{85FA}',
-    '\u{96A3}',
-    '\u{9C57}',
-    '\u{9E9F}',
-    '\u{6797}',
-    '\u{6DCB}',
-    '\u{81E8}',
-    '\u{7ACB}',
-    '\u{7B20}',
-    '\u{7C92}',
-    '\u{72C0}',
-    '\u{7099}',
-    '\u{8B58}',
-    '\u{4EC0}',
-    '\u{8336}',
-    '\u{523A}',
-    '\u{5207}',
-    '\u{5EA6}',
-    '\u{62D3}',
-    '\u{7CD6}',
-    '\u{5B85}',
-    '\u{6D1E}',
-    '\u{66B4}',
-    '\u{8F3B}',
-    '\u{884C}',
-    '\u{964D}',
-    '\u{898B}',
-    '\u{5ED3}',
-    '\u{5140}',
-    '\u{55C0}',
-    '\u{585A}',
-    '\u{6674}',
-    '\u{51DE}',
-    '\u{732A}',
-    '\u{76CA}',
-    '\u{793C}',
-    '\u{795E}',
-    '\u{7965}',
-    '\u{798F}',
-    '\u{9756}',
-    '\u{7CBE}',
-    '\u{7FBD}',
-    '\u{8612}',
-    '\u{8AF8}',
-    '\u{9038}',
-    '\u{90FD}',
-    '\u{98EF}',
-    '\u{98FC}',
-    '\u{9928}',
-    '\u{9DB4}',
-    '\u{90DE}',
-    '\u{96B7}',
-    '\u{4FAE}',
-    '\u{50E7}',
-    '\u{514D}',
-    '\u{52C9}',
-    '\u{52E4}',
-    '\u{5351}',
-    '\u{559D}',
-    '\u{5606}',
-    '\u{5668}',
-    '\u{5840}',
-    '\u{58A8}',
-    '\u{5C64}',
-    '\u{5C6E}',
-    '\u{6094}',
-    '\u{6168}',
-    '\u{618E}',
-    '\u{61F2}',
-    '\u{654F}',
-    '\u{65E2}',
-    '\u{6691}',
-    '\u{6885}',
-    '\u{6D77}',
-    '\u{6E1A}',
-    '\u{6F22}',
-    '\u{716E}',
-    '\u{722B}',
-    '\u{7422}',
-    '\u{7891}',
-    '\u{793E}',
-    '\u{7949}',
-    '\u{7948}',
-    '\u{7950}',
-    '\u{7956}',
-    '\u{795D}',
-    '\u{798D}',
-    '\u{798E}',
-    '\u{7A40}',
-    '\u{7A81}',
-    '\u{7BC0}',
-    '\u{7DF4}',
-    '\u{7E09}',
-    '\u{7E41}',
-    '\u{7F72}',
-    '\u{8005}',
-    '\u{81ED}',
-    '\u{8279}',
-    '\u{8279}',
-    '\u{8457}',
-    '\u{8910}',
-    '\u{8996}',
-    '\u{8B01}',
-    '\u{8B39}',
-    '\u{8CD3}',
-    '\u{8D08}',
-    '\u{8FB6}',
-    '\u{9038}',
-    '\u{96E3}',
-    '\u{97FF}',
-    '\u{983B}',
-    '\u{6075}',
-    '\u{242EE}',
-    '\u{8218}',
-    '\u{4E26}',
-    '\u{51B5}',
-    '\u{5168}',
-    '\u{4F80}',
-    '\u{5145}',
-    '\u{5180}',
-    '\u{52C7}',
-    '\u{52FA}',
-    '\u{559D}',
-    '\u{5555}',
-    '\u{5599}',
-    '\u{55E2}',
-    '\u{585A}',
-    '\u{58B3}',
-    '\u{5944}',
-    '\u{5954}',
-    '\u{5A62}',
-    '\u{5B28}',
-    '\u{5ED2}',
-    '\u{5ED9}',
-    '\u{5F69}',
-    '\u{5FAD}',
-    '\u{60D8}',
-    '\u{614E}',
-    '\u{6108}',
-    '\u{618E}',
-    '\u{6160}',
-    '\u{61F2}',
-    '\u{6234}',
-    '\u{63C4}',
-    '\u{641C}',
-    '\u{6452}',
-    '\u{6556}',
-    '\u{6674}',
-    '\u{6717}',
-    '\u{671B}',
-    '\u{6756}',
-    '\u{6B79}',
-    '\u{6BBA}',
-    '\u{6D41}',
-    '\u{6EDB}',
-    '\u{6ECB}',
-    '\u{6F22}',
-    '\u{701E}',
-    '\u{716E}',
-    '\u{77A7}',
-    '\u{7235}',
-    '\u{72AF}',
-    '\u{732A}',
-    '\u{7471}',
-    '\u{7506}',
-    '\u{753B}',
-    '\u{761D}',
-    '\u{761F}',
-    '\u{76CA}',
-    '\u{76DB}',
-    '\u{76F4}',
-    '\u{774A}',
-    '\u{7740}',
-    '\u{78CC}',
-    '\u{7AB1}',
-    '\u{7BC0}',
-    '\u{7C7B}',
-    '\u{7D5B}',
-    '\u{7DF4}',
-    '\u{7F3E}',
-    '\u{8005}',
-    '\u{8352}',
-    '\u{83EF}',
-    '\u{8779}',
-    '\u{8941}',
-    '\u{8986}',
-    '\u{8996}',
-    '\u{8ABF}',
-    '\u{8AF8}',
-    '\u{8ACB}',
-    '\u{8B01}',
-    '\u{8AFE}',
-    '\u{8AED}',
-    '\u{8B39}',
-    '\u{8B8A}',
-    '\u{8D08}',
-    '\u{8F38}',
-    '\u{9072}',
-    '\u{9199}',
-    '\u{9276}',
-    '\u{967C}',
-    '\u{96E3}',
-    '\u{9756}',
-    '\u{97DB}',
-    '\u{97FF}',
-    '\u{980B}',
-    '\u{983B}',
-    '\u{9B12}',
-    '\u{9F9C}',
-    '\u{2284A}',
-    '\u{22844}',
-    '\u{233D5}',
-    '\u{3B9D}',
-    '\u{4018}',
-    '\u{4039}',
-    '\u{25249}',
-    '\u{25CD0}',
-    '\u{27ED3}',
-    '\u{9F43}',
-    '\u{9F8E}',
-    '\u{05D9}',
-    '\u{05B4}',
-    '\u{05F2}',
-    '\u{05B7}',
-    '\u{05E9}',
-    '\u{05C1}',
-    '\u{05E9}',
-    '\u{05C2}',
-    '\u{05E9}',
-    '\u{05BC}',
-    '\u{05C1}',
-    '\u{05E9}',
-    '\u{05BC}',
-    '\u{05C2}',
-    '\u{05D0}',
-    '\u{05B7}',
-    '\u{05D0}',
-    '\u{05B8}',
-    '\u{05D0}',
-    '\u{05BC}',
-    '\u{05D1}',
-    '\u{05BC}',
-    '\u{05D2}',
-    '\u{05BC}',
-    '\u{05D3}',
-    '\u{05BC}',
-    '\u{05D4}',
-    '\u{05BC}',
-    '\u{05D5}',
-    '\u{05BC}',
-    '\u{05D6}',
-    '\u{05BC}',
-    '\u{05D8}',
-    '\u{05BC}',
-    '\u{05D9}',
-    '\u{05BC}',
-    '\u{05DA}',
-    '\u{05BC}',
-    '\u{05DB}',
-    '\u{05BC}',
-    '\u{05DC}',
-    '\u{05BC}',
-    '\u{05DE}',
-    '\u{05BC}',
-    '\u{05E0}',
-    '\u{05BC}',
-    '\u{05E1}',
-    '\u{05BC}',
-    '\u{05E3}',
-    '\u{05BC}',
-    '\u{05E4}',
-    '\u{05BC}',
-    '\u{05E6}',
-    '\u{05BC}',
-    '\u{05E7}',
-    '\u{05BC}',
-    '\u{05E8}',
-    '\u{05BC}',
-    '\u{05E9}',
-    '\u{05BC}',
-    '\u{05EA}',
-    '\u{05BC}',
-    '\u{05D5}',
-    '\u{05B9}',
-    '\u{05D1}',
-    '\u{05BF}',
-    '\u{05DB}',
-    '\u{05BF}',
-    '\u{05E4}',
-    '\u{05BF}',
-    '\u{105D2}',
-    '\u{0307}',
-    '\u{105DA}',
-    '\u{0307}',
-    '\u{11099}',
-    '\u{110BA}',
-    '\u{1109B}',
-    '\u{110BA}',
-    '\u{110A5}',
-    '\u{110BA}',
-    '\u{11131}',
-    '\u{11127}',
-    '\u{11132}',
-    '\u{11127}',
-    '\u{11347}',
-    '\u{1133E}',
-    '\u{11347}',
-    '\u{11357}',
-    '\u{11382}',
-    '\u{113C9}',
-    '\u{11384}',
-    '\u{113BB}',
-    '\u{1138B}',
-    '\u{113C2}',
-    '\u{11390}',
-    '\u{113C9}',
-    '\u{113C2}',
-    '\u{113C2}',
-    '\u{113C2}',
-    '\u{113B8}',
-    '\u{113C2}',
-    '\u{113C9}',
-    '\u{114B9}',
-    '\u{114BA}',
-    '\u{114B9}',
-    '\u{114B0}',
-    '\u{114B9}',
-    '\u{114BD}',
-    '\u{115B8}',
-    '\u{115AF}',
-    '\u{115B9}',
-    '\u{115AF}',
-    '\u{11935}',
-    '\u{11930}',
-    '\u{1611E}',
-    '\u{1611E}',
-    '\u{1611E}',
-    '\u{16129}',
-    '\u{1611E}',
-    '\u{1611F}',
-    '\u{16129}',
-    '\u{1611F}',
-    '\u{1611E}',
-    '\u{16120}',
-    '\u{1611E}',
-    '\u{1611E}',
-    '\u{1611F}',
-    '\u{1611E}',
-    '\u{16129}',
-    '\u{1611F}',
-    '\u{1611E}',
-    '\u{1611E}',
-    '\u{16120}',
-    '\u{16D67}',
-    '\u{16D67}',
-    '\u{16D63}',
-    '\u{16D67}',
-    '\u{16D63}',
-    '\u{16D67}',
-    '\u{16D67}',
-    '\u{1D157}',
-    '\u{1D165}',
-    '\u{1D158}',
-    '\u{1D165}',
-    '\u{1D158}',
-    '\u{1D165}',
-    '\u{1D16E}',
-    '\u{1D158}',
-    '\u{1D165}',
-    '\u{1D16F}',
-    '\u{1D158}',
-    '\u{1D165}',
-    '\u{1D170}',
-    '\u{1D158}',
-    '\u{1D165}',
-    '\u{1D171}',
-    '\u{1D158}',
-    '\u{1D165}',
-    '\u{1D172}',
-    '\u{1D1B9}',
-    '\u{1D165}',
-    '\u{1D1BA}',
-    '\u{1D165}',
-    '\u{1D1B9}',
-    '\u{1D165}',
-    '\u{1D16E}',
-    '\u{1D1BA}',
-    '\u{1D165}',
-    '\u{1D16E}',
-    '\u{1D1B9}',
-    '\u{1D165}',
-    '\u{1D16F}',
-    '\u{1D1BA}',
-    '\u{1D165}',
-    '\u{1D16F}',
-    '\u{4E3D}',
-    '\u{4E38}',
-    '\u{4E41}',
-    '\u{20122}',
-    '\u{4F60}',
-    '\u{4FAE}',
-    '\u{4FBB}',
-    '\u{5002}',
-    '\u{507A}',
-    '\u{5099}',
-    '\u{50E7}',
-    '\u{50CF}',
-    '\u{349E}',
-    '\u{2063A}',
-    '\u{514D}',
-    '\u{5154}',
-    '\u{5164}',
-    '\u{5177}',
-    '\u{2051C}',
-    '\u{34B9}',
-    '\u{5167}',
-    '\u{518D}',
-    '\u{2054B}',
-    '\u{5197}',
-    '\u{51A4}',
-    '\u{4ECC}',
-    '\u{51AC}',
-    '\u{51B5}',
-    '\u{291DF}',
-    '\u{51F5}',
-    '\u{5203}',
-    '\u{34DF}',
-    '\u{523B}',
-    '\u{5246}',
-    '\u{5272}',
-    '\u{5277}',
-    '\u{3515}',
-    '\u{52C7}',
-    '\u{52C9}',
-    '\u{52E4}',
-    '\u{52FA}',
-    '\u{5305}',
-    '\u{5306}',
-    '\u{5317}',
-    '\u{5349}',
-    '\u{5351}',
-    '\u{535A}',
-    '\u{5373}',
-    '\u{537D}',
-    '\u{537F}',
-    '\u{537F}',
-    '\u{537F}',
-    '\u{20A2C}',
-    '\u{7070}',
-    '\u{53CA}',
-    '\u{53DF}',
-    '\u{20B63}',
-    '\u{53EB}',
-    '\u{53F1}',
-    '\u{5406}',
-    '\u{549E}',
-    '\u{5438}',
-    '\u{5448}',
-    '\u{5468}',
-    '\u{54A2}',
-    '\u{54F6}',
-    '\u{5510}',
-    '\u{5553}',
-    '\u{5563}',
-    '\u{5584}',
-    '\u{5584}',
-    '\u{5599}',
-    '\u{55AB}',
-    '\u{55B3}',
-    '\u{55C2}',
-    '\u{5716}',
-    '\u{5606}',
-    '\u{5717}',
-    '\u{5651}',
-    '\u{5674}',
-    '\u{5207}',
-    '\u{58EE}',
-    '\u{57CE}',
-    '\u{57F4}',
-    '\u{580D}',
-    '\u{578B}',
-    '\u{5832}',
-    '\u{5831}',
-    '\u{58AC}',
-    '\u{214E4}',
-    '\u{58F2}',
-    '\u{58F7}',
-    '\u{5906}',
-    '\u{591A}',
-    '\u{5922}',
-    '\u{5962}',
-    '\u{216A8}',
-    '\u{216EA}',
-    '\u{59EC}',
-    '\u{5A1B}',
-    '\u{5A27}',
-    '\u{59D8}',
-    '\u{5A66}',
-    '\u{36EE}',
-    '\u{36FC}',
-    '\u{5B08}',
-    '\u{5B3E}',
-    '\u{5B3E}',
-    '\u{219C8}',
-    '\u{5BC3}',
-    '\u{5BD8}',
-    '\u{5BE7}',
-    '\u{5BF3}',
-    '\u{21B18}',
-    '\u{5BFF}',
-    '\u{5C06}',
-    '\u{5F53}',
-    '\u{5C22}',
-    '\u{3781}',
-    '\u{5C60}',
-    '\u{5C6E}',
-    '\u{5CC0}',
-    '\u{5C8D}',
-    '\u{21DE4}',
-    '\u{5D43}',
-    '\u{21DE6}',
-    '\u{5D6E}',
-    '\u{5D6B}',
-    '\u{5D7C}',
-    '\u{5DE1}',
-    '\u{5DE2}',
-    '\u{382F}',
-    '\u{5DFD}',
-    '\u{5E28}',
-    '\u{5E3D}',
-    '\u{5E69}',
-    '\u{3862}',
-    '\u{22183}',
-    '\u{387C}',
-    '\u{5EB0}',
-    '\u{5EB3}',
-    '\u{5EB6}',
-    '\u{5ECA}',
-    '\u{2A392}',
-    '\u{5EFE}',
-    '\u{22331}',
-    '\u{22331}',
-    '\u{8201}',
-    '\u{5F22}',
-    '\u{5F22}',
-    '\u{38C7}',
-    '\u{232B8}',
-    '\u{261DA}',
-    '\u{5F62}',
-    '\u{5F6B}',
-    '\u{38E3}',
-    '\u{5F9A}',
-    '\u{5FCD}',
-    '\u{5FD7}',
-    '\u{5FF9}',
-    '\u{6081}',
-    '\u{393A}',
-    '\u{391C}',
-    '\u{6094}',
-    '\u{226D4}',
-    '\u{60C7}',
-    '\u{6148}',
-    '\u{614C}',
-    '\u{614E}',
-    '\u{614C}',
-    '\u{617A}',
-    '\u{618E}',
-    '\u{61B2}',
-    '\u{61A4}',
-    '\u{61AF}',
-    '\u{61DE}',
-    '\u{61F2}',
-    '\u{61F6}',
-    '\u{6210}',
-    '\u{621B}',
-    '\u{625D}',
-    '\u{62B1}',
-    '\u{62D4}',
-    '\u{6350}',
-    '\u{22B0C}',
-    '\u{633D}',
-    '\u{62FC}',
-    '\u{6368}',
-    '\u{6383}',
-    '\u{63E4}',
-    '\u{22BF1}',
-    '\u{6422}',
-    '\u{63C5}',
-    '\u{63A9}',
-    '\u{3A2E}',
-    '\u{6469}',
-    '\u{647E}',
-    '\u{649D}',
-    '\u{6477}',
-    '\u{3A6C}',
-    '\u{654F}',
-    '\u{656C}',
-    '\u{2300A}',
-    '\u{65E3}',
-    '\u{66F8}',
-    '\u{6649}',
-    '\u{3B19}',
-    '\u{6691}',
-    '\u{3B08}',
-    '\u{3AE4}',
-    '\u{5192}',
-    '\u{5195}',
-    '\u{6700}',
-    '\u{669C}',
-    '\u{80AD}',
-    '\u{43D9}',
-    '\u{6717}',
-    '\u{671B}',
-    '\u{6721}',
-    '\u{675E}',
-    '\u{6753}',
-    '\u{233C3}',
-    '\u{3B49}',
-    '\u{67FA}',
-    '\u{6785}',
-    '\u{6852}',
-    '\u{6885}',
-    '\u{2346D}',
-    '\u{688E}',
-    '\u{681F}',
-    '\u{6914}',
-    '\u{3B9D}',
-    '\u{6942}',
-    '\u{69A3}',
-    '\u{69EA}',
-    '\u{6AA8}',
-    '\u{236A3}',
-    '\u{6ADB}',
-    '\u{3C18}',
-    '\u{6B21}',
-    '\u{238A7}',
-    '\u{6B54}',
-    '\u{3C4E}',
-    '\u{6B72}',
-    '\u{6B9F}',
-    '\u{6BBA}',
-    '\u{6BBB}',
-    '\u{23A8D}',
-    '\u{21D0B}',
-    '\u{23AFA}',
-    '\u{6C4E}',
-    '\u{23CBC}',
-    '\u{6CBF}',
-    '\u{6CCD}',
-    '\u{6C67}',
-    '\u{6D16}',
-    '\u{6D3E}',
-    '\u{6D77}',
-    '\u{6D41}',
-    '\u{6D69}',
-    '\u{6D78}',
-    '\u{6D85}',
-    '\u{23D1E}',
-    '\u{6D34}',
-    '\u{6E2F}',
-    '\u{6E6E}',
-    '\u{3D33}',
-    '\u{6ECB}',
-    '\u{6EC7}',
-    '\u{23ED1}',
-    '\u{6DF9}',
-    '\u{6F6E}',
-    '\u{23F5E}',
-    '\u{23F8E}',
-    '\u{6FC6}',
-    '\u{7039}',
-    '\u{701E}',
-    '\u{701B}',
-    '\u{3D96}',
-    '\u{704A}',
-    '\u{707D}',
-    '\u{7077}',
-    '\u{70AD}',
-    '\u{20525}',
-    '\u{7145}',
-    '\u{24263}',
-    '\u{719C}',
-    '\u{243AB}',
-    '\u{7228}',
-    '\u{7235}',
-    '\u{7250}',
-    '\u{24608}',
-    '\u{7280}',
-    '\u{7295}',
-    '\u{24735}',
-    '\u{24814}',
-    '\u{737A}',
-    '\u{738B}',
-    '\u{3EAC}',
-    '\u{73A5}',
-    '\u{3EB8}',
-    '\u{3EB8}',
-    '\u{7447}',
-    '\u{745C}',
-    '\u{7471}',
-    '\u{7485}',
-    '\u{74CA}',
-    '\u{3F1B}',
-    '\u{7524}',
-    '\u{24C36}',
-    '\u{753E}',
-    '\u{24C92}',
-    '\u{7570}',
-    '\u{2219F}',
-    '\u{7610}',
-    '\u{24FA1}',
-    '\u{24FB8}',
-    '\u{25044}',
-    '\u{3FFC}',
-    '\u{4008}',
-    '\u{76F4}',
-    '\u{250F3}',
-    '\u{250F2}',
-    '\u{25119}',
-    '\u{25133}',
-    '\u{771E}',
-    '\u{771F}',
-    '\u{771F}',
-    '\u{774A}',
-    '\u{4039}',
-    '\u{778B}',
-    '\u{4046}',
-    '\u{4096}',
-    '\u{2541D}',
-    '\u{784E}',
-    '\u{788C}',
-    '\u{78CC}',
-    '\u{40E3}',
-    '\u{25626}',
-    '\u{7956}',
-    '\u{2569A}',
-    '\u{256C5}',
-    '\u{798F}',
-    '\u{79EB}',
-    '\u{412F}',
-    '\u{7A40}',
-    '\u{7A4A}',
-    '\u{7A4F}',
-    '\u{2597C}',
-    '\u{25AA7}',
-    '\u{25AA7}',
-    '\u{7AEE}',
-    '\u{4202}',
-    '\u{25BAB}',
-    '\u{7BC6}',
-    '\u{7BC9}',
-    '\u{4227}',
-    '\u{25C80}',
-    '\u{7CD2}',
-    '\u{42A0}',
-    '\u{7CE8}',
-    '\u{7CE3}',
-    '\u{7D00}',
-    '\u{25F86}',
-    '\u{7D63}',
-    '\u{4301}',
-    '\u{7DC7}',
-    '\u{7E02}',
-    '\u{7E45}',
-    '\u{4334}',
-    '\u{26228}',
-    '\u{26247}',
-    '\u{4359}',
-    '\u{262D9}',
-    '\u{7F7A}',
-    '\u{2633E}',
-    '\u{7F95}',
-    '\u{7FFA}',
-    '\u{8005}',
-    '\u{264DA}',
-    '\u{26523}',
-    '\u{8060}',
-    '\u{265A8}',
-    '\u{8070}',
-    '\u{2335F}',
-    '\u{43D5}',
-    '\u{80B2}',
-    '\u{8103}',
-    '\u{440B}',
-    '\u{813E}',
-    '\u{5AB5}',
-    '\u{267A7}',
-    '\u{267B5}',
-    '\u{23393}',
-    '\u{2339C}',
-    '\u{8201}',
-    '\u{8204}',
-    '\u{8F9E}',
-    '\u{446B}',
-    '\u{8291}',
-    '\u{828B}',
-    '\u{829D}',
-    '\u{52B3}',
-    '\u{82B1}',
-    '\u{82B3}',
-    '\u{82BD}',
-    '\u{82E6}',
-    '\u{26B3C}',
-    '\u{82E5}',
-    '\u{831D}',
-    '\u{8363}',
-    '\u{83AD}',
-    '\u{8323}',
-    '\u{83BD}',
-    '\u{83E7}',
-    '\u{8457}',
-    '\u{8353}',
-    '\u{83CA}',
-    '\u{83CC}',
-    '\u{83DC}',
-    '\u{26C36}',
-    '\u{26D6B}',
-    '\u{26CD5}',
-    '\u{452B}',
-    '\u{84F1}',
-    '\u{84F3}',
-    '\u{8516}',
-    '\u{273CA}',
-    '\u{8564}',
-    '\u{26F2C}',
-    '\u{455D}',
-    '\u{4561}',
-    '\u{26FB1}',
-    '\u{270D2}',
-    '\u{456B}',
-    '\u{8650}',
-    '\u{865C}',
-    '\u{8667}',
-    '\u{8669}',
-    '\u{86A9}',
-    '\u{8688}',
-    '\u{870E}',
-    '\u{86E2}',
-    '\u{8779}',
-    '\u{8728}',
-    '\u{876B}',
-    '\u{8786}',
-    '\u{45D7}',
-    '\u{87E1}',
-    '\u{8801}',
-    '\u{45F9}',
-    '\u{8860}',
-    '\u{8863}',
-    '\u{27667}',
-    '\u{88D7}',
-    '\u{88DE}',
-    '\u{4635}',
-    '\u{88FA}',
-    '\u{34BB}',
-    '\u{278AE}',
-    '\u{27966}',
-    '\u{46BE}',
-    '\u{46C7}',
-    '\u{8AA0}',
-    '\u{8AED}',
-    '\u{8B8A}',
-    '\u{8C55}',
-    '\u{27CA8}',
-    '\u{8CAB}',
-    '\u{8CC1}',
-    '\u{8D1B}',
-    '\u{8D77}',
-    '\u{27F2F}',
-    '\u{20804}',
-    '\u{8DCB}',
-    '\u{8DBC}',
-    '\u{8DF0}',
-    '\u{208DE}',
-    '\u{8ED4}',
-    '\u{8F38}',
-    '\u{285D2}',
-    '\u{285ED}',
-    '\u{9094}',
-    '\u{90F1}',
-    '\u{9111}',
-    '\u{2872E}',
-    '\u{911B}',
-    '\u{9238}',
-    '\u{92D7}',
-    '\u{92D8}',
-    '\u{927C}',
-    '\u{93F9}',
-    '\u{9415}',
-    '\u{28BFA}',
-    '\u{958B}',
-    '\u{4995}',
-    '\u{95B7}',
-    '\u{28D77}',
-    '\u{49E6}',
-    '\u{96C3}',
-    '\u{5DB2}',
-    '\u{9723}',
-    '\u{29145}',
-    '\u{2921A}',
-    '\u{4A6E}',
-    '\u{4A76}',
-    '\u{97E0}',
-    '\u{2940A}',
-    '\u{4AB2}',
-    '\u{29496}',
-    '\u{980B}',
-    '\u{980B}',
-    '\u{9829}',
-    '\u{295B6}',
-    '\u{98E2}',
-    '\u{4B33}',
-    '\u{9929}',
-    '\u{99A7}',
-    '\u{99C2}',
-    '\u{99FE}',
-    '\u{4BCE}',
-    '\u{29B30}',
-    '\u{9B12}',
-    '\u{9C40}',
-    '\u{9CFD}',
-    '\u{4CCE}',
-    '\u{4CED}',
-    '\u{9D67}',
-    '\u{2A0CE}',
-    '\u{4CF8}',
-    '\u{2A105}',
-    '\u{2A20E}',
-    '\u{2A291}',
-    '\u{9EBB}',
-    '\u{4D56}',
-    '\u{9EF9}',
-    '\u{9EFE}',
-    '\u{9F05}',
-    '\u{9F0F}',
-    '\u{9F16}',
-    '\u{9F3B}',
-    '\u{2A600}',
-];
-
-pub(crate) const CANONICAL_DECOMPOSED_SALT: &[u16] = &[
-    0x571, 0x003, 0x000, 0x000, 0x03D, 0x160, 0x000, 0x27F, 0x0F7, 0x1B1, 0x000, 0x002, 0x004,
-    0x033, 0x136, 0x017, 0x001, 0x000, 0x193, 0x1EE, 0x000, 0x006, 0x000, 0x054, 0x034, 0x002,
-    0x054, 0x248, 0x008, 0x006, 0x003, 0x000, 0x000, 0x000, 0x064, 0x001, 0x000, 0x000, 0x002,
-    0x005, 0x000, 0x000, 0x01E, 0x035, 0x009, 0x07D, 0x004, 0x012, 0x058, 0x000, 0x000, 0x000,
-    0x002, 0x04C, 0x000, 0x000, 0x006, 0x068, 0x000, 0x006, 0x000, 0x00A, 0x006, 0x001, 0x0F6,
-    0x000, 0x000, 0x002, 0x046, 0x000, 0x001, 0x000, 0x003, 0x000, 0x140, 0x000, 0x00A, 0x0DF,
-    0x001, 0x000, 0x003, 0x004, 0x008, 0x005, 0x004, 0x014, 0x030, 0x05B, 0x000, 0x018, 0x0A8,
-    0x000, 0x048, 0x004, 0x000, 0x005, 0x000, 0x042, 0x000, 0x068, 0x000, 0x000, 0x02D, 0x000,
-    0x000, 0x000, 0x032, 0x006, 0x000, 0x01F, 0x061, 0x000, 0x00D, 0x000, 0x013, 0x005, 0x027,
-    0x002, 0x002, 0x002, 0x002, 0x013, 0x037, 0x010, 0x000, 0x019, 0x006, 0x000, 0x02C, 0x05F,
-    0x05F, 0x000, 0x001, 0x000, 0x005, 0x000, 0x000, 0x005, 0x006, 0x022, 0x03C, 0x010, 0x000,
-    0x000, 0x000, 0x012, 0x002, 0x004, 0x051, 0x000, 0x000, 0x002, 0x032, 0x006, 0x001, 0x000,
-    0x011, 0x005, 0x004, 0x075, 0x032, 0x00A, 0x000, 0x016, 0x00E, 0x001, 0x00F, 0x027, 0x000,
-    0x005, 0x001, 0x00A, 0x007, 0x010, 0x004, 0x001, 0x000, 0x007, 0x00F, 0x002, 0x005, 0x05E,
-    0x000, 0x048, 0x017, 0x000, 0x000, 0x004, 0x000, 0x002, 0x03C, 0x01C, 0x00B, 0x000, 0x004,
-    0x023, 0x001, 0x00C, 0x00E, 0x005, 0x01C, 0x000, 0x020, 0x001, 0x003, 0x000, 0x007, 0x008,
-    0x004, 0x000, 0x000, 0x02D, 0x008, 0x000, 0x000, 0x033, 0x013, 0x002, 0x000, 0x003, 0x000,
-    0x006, 0x03C, 0x020, 0x000, 0x009, 0x000, 0x025, 0x012, 0x009, 0x000, 0x000, 0x03A, 0x022,
-    0x000, 0x002, 0x001, 0x01E, 0x009, 0x002, 0x002, 0x003, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x00B, 0x001, 0x001, 0x01B, 0x004, 0x007, 0x00E, 0x003, 0x000, 0x003, 0x007, 0x000,
-    0x002, 0x002, 0x026, 0x000, 0x008, 0x003, 0x004, 0x002, 0x002, 0x008, 0x009, 0x000, 0x001,
-    0x006, 0x001, 0x003, 0x002, 0x001, 0x008, 0x000, 0x004, 0x009, 0x00C, 0x013, 0x000, 0x000,
-    0x005, 0x000, 0x00A, 0x000, 0x014, 0x000, 0x014, 0x000, 0x001, 0x000, 0x000, 0x000, 0x01C,
-    0x016, 0x000, 0x000, 0x002, 0x004, 0x000, 0x000, 0x000, 0x00A, 0x000, 0x000, 0x007, 0x002,
-    0x000, 0x000, 0x004, 0x001, 0x00A, 0x000, 0x000, 0x009, 0x005, 0x029, 0x000, 0x000, 0x001,
-    0x020, 0x003, 0x006, 0x002, 0x001, 0x00E, 0x013, 0x001, 0x024, 0x000, 0x001, 0x001, 0x003,
-    0x004, 0x002, 0x002, 0x00A, 0x006, 0x008, 0x000, 0x00A, 0x000, 0x004, 0x000, 0x00D, 0x00B,
-    0x000, 0x013, 0x009, 0x000, 0x000, 0x012, 0x000, 0x006, 0x000, 0x000, 0x002, 0x000, 0x000,
-    0x00C, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000, 0x013, 0x002, 0x000, 0x002, 0x000,
-    0x000, 0x000, 0x000, 0x008, 0x000, 0x000, 0x001, 0x001, 0x004, 0x010, 0x000, 0x00B, 0x00B,
-    0x002, 0x001, 0x000, 0x001, 0x001, 0x002, 0x002, 0x001, 0x001, 0x002, 0x004, 0x008, 0x000,
-    0x000, 0x001, 0x029, 0x001, 0x00E, 0x000, 0x000, 0x00E, 0x000, 0x00B, 0x000, 0x017, 0x005,
-    0x000, 0x015, 0x008, 0x006, 0x008, 0x000, 0x002, 0x00C, 0x000, 0x000, 0x000, 0x008, 0x000,
-    0x000, 0x000, 0x000, 0x00C, 0x000, 0x000, 0x004, 0x000, 0x000, 0x000, 0x00F, 0x000, 0x000,
-    0x001, 0x007, 0x000, 0x011, 0x000, 0x00D, 0x008, 0x00E, 0x00B, 0x000, 0x002, 0x001, 0x000,
-    0x004, 0x005, 0x003, 0x003, 0x001, 0x003, 0x008, 0x001, 0x01A, 0x001, 0x005, 0x001, 0x005,
-    0x006, 0x000, 0x001, 0x000, 0x000, 0x000, 0x010, 0x00F, 0x002, 0x004, 0x006, 0x002, 0x002,
-    0x00C, 0x017, 0x003, 0x000, 0x003, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x022, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x01C, 0x014, 0x001, 0x000,
-    0x002, 0x004, 0x00F, 0x000, 0x007, 0x001, 0x000, 0x002, 0x001, 0x000, 0x000, 0x000, 0x006,
-    0x009, 0x003, 0x02C, 0x009, 0x005, 0x000, 0x000, 0x00B, 0x008, 0x01D, 0x000, 0x001, 0x000,
-    0x000, 0x000, 0x001, 0x008, 0x003, 0x005, 0x000, 0x004, 0x000, 0x000, 0x003, 0x00A, 0x003,
-    0x000, 0x005, 0x002, 0x004, 0x00A, 0x000, 0x000, 0x003, 0x002, 0x000, 0x002, 0x000, 0x00E,
-    0x000, 0x000, 0x005, 0x000, 0x009, 0x017, 0x003, 0x004, 0x000, 0x001, 0x004, 0x000, 0x000,
-    0x007, 0x015, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x009, 0x003, 0x001, 0x001,
-    0x001, 0x006, 0x00A, 0x000, 0x000, 0x006, 0x000, 0x001, 0x000, 0x000, 0x002, 0x000, 0x000,
-    0x001, 0x001, 0x002, 0x000, 0x000, 0x000, 0x003, 0x003, 0x012, 0x001, 0x006, 0x004, 0x007,
-    0x000, 0x001, 0x000, 0x02E, 0x002, 0x001, 0x00B, 0x008, 0x000, 0x005, 0x000, 0x002, 0x004,
-    0x009, 0x000, 0x000, 0x008, 0x005, 0x003, 0x001, 0x006, 0x000, 0x000, 0x003, 0x000, 0x003,
-    0x006, 0x006, 0x000, 0x003, 0x007, 0x000, 0x006, 0x001, 0x000, 0x000, 0x006, 0x004, 0x000,
-    0x000, 0x001, 0x000, 0x002, 0x000, 0x005, 0x000, 0x022, 0x014, 0x006, 0x002, 0x000, 0x000,
-    0x000, 0x000, 0x00C, 0x000, 0x00A, 0x001, 0x002, 0x007, 0x000, 0x002, 0x001, 0x001, 0x004,
-    0x000, 0x000, 0x012, 0x002, 0x001, 0x000, 0x000, 0x000, 0x003, 0x003, 0x000, 0x005, 0x000,
-    0x000, 0x003, 0x000, 0x003, 0x000, 0x006, 0x000, 0x005, 0x001, 0x000, 0x008, 0x004, 0x000,
-    0x009, 0x001, 0x00A, 0x00E, 0x000, 0x005, 0x00E, 0x007, 0x000, 0x000, 0x008, 0x000, 0x000,
-    0x000, 0x000, 0x004, 0x000, 0x001, 0x001, 0x000, 0x000, 0x002, 0x000, 0x001, 0x000, 0x010,
-    0x016, 0x001, 0x001, 0x000, 0x000, 0x000, 0x011, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000,
-    0x000, 0x002, 0x000, 0x001, 0x006, 0x002, 0x01A, 0x000, 0x00B, 0x004, 0x000, 0x000, 0x003,
-    0x006, 0x001, 0x009, 0x00F, 0x002, 0x005, 0x001, 0x01A, 0x000, 0x000, 0x000, 0x001, 0x002,
-    0x002, 0x00F, 0x000, 0x000, 0x00A, 0x002, 0x003, 0x002, 0x007, 0x006, 0x000, 0x007, 0x004,
-    0x00C, 0x000, 0x000, 0x001, 0x007, 0x000, 0x000, 0x000, 0x000, 0x000, 0x004, 0x000, 0x000,
-    0x000, 0x002, 0x000, 0x000, 0x000, 0x00A, 0x006, 0x000, 0x002, 0x000, 0x000, 0x000, 0x00D,
-    0x000, 0x003, 0x001, 0x00A, 0x000, 0x00C, 0x000, 0x001, 0x000, 0x007, 0x003, 0x002, 0x001,
-    0x002, 0x001, 0x007, 0x003, 0x002, 0x001, 0x004, 0x001, 0x000, 0x000, 0x008, 0x006, 0x000,
-    0x000, 0x001, 0x00D, 0x004, 0x001, 0x002, 0x001, 0x004, 0x000, 0x000, 0x000, 0x007, 0x002,
-    0x000, 0x000, 0x000, 0x000, 0x013, 0x000, 0x000, 0x000, 0x000, 0x003, 0x011, 0x001, 0x001,
-    0x003, 0x006, 0x000, 0x006, 0x003, 0x001, 0x000, 0x000, 0x000, 0x00B, 0x000, 0x004, 0x006,
-    0x000, 0x000, 0x005, 0x000, 0x002, 0x000, 0x001, 0x001, 0x005, 0x001, 0x007, 0x005, 0x000,
-    0x001, 0x001, 0x000, 0x001, 0x001, 0x007, 0x009, 0x001, 0x00C, 0x004, 0x002, 0x001, 0x000,
-    0x005, 0x000, 0x000, 0x001, 0x002, 0x001, 0x008, 0x005, 0x00B, 0x002, 0x000, 0x007, 0x001,
-    0x004, 0x016, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x016, 0x000,
-    0x000, 0x00E, 0x000, 0x000, 0x002, 0x004, 0x000, 0x000, 0x002, 0x000, 0x004, 0x006, 0x001,
-    0x000, 0x000, 0x000, 0x00C, 0x007, 0x009, 0x004, 0x003, 0x001, 0x001, 0x009, 0x00D, 0x001,
-    0x002, 0x003, 0x000, 0x004, 0x004, 0x004, 0x002, 0x000, 0x001, 0x00B, 0x000, 0x012, 0x000,
-    0x003, 0x003, 0x001, 0x001, 0x001, 0x00E, 0x000, 0x001, 0x001, 0x004, 0x001, 0x002, 0x000,
-    0x000, 0x000, 0x001, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x013, 0x000, 0x000, 0x000,
-    0x000, 0x003, 0x000, 0x000, 0x000, 0x009, 0x000, 0x001, 0x007, 0x000, 0x002, 0x000, 0x00C,
-    0x001, 0x003, 0x000, 0x001, 0x000, 0x005, 0x001, 0x000, 0x001, 0x003, 0x002, 0x009, 0x001,
-    0x000, 0x008, 0x001, 0x005, 0x002, 0x000, 0x004, 0x000, 0x001, 0x005, 0x000, 0x008, 0x003,
-    0x000, 0x004, 0x000, 0x000, 0x006, 0x003, 0x003, 0x002, 0x000, 0x002, 0x000, 0x002, 0x002,
-    0x008, 0x000, 0x00A, 0x004, 0x012, 0x006, 0x002, 0x003, 0x002, 0x000, 0x001, 0x000, 0x000,
-    0x000, 0x007, 0x001, 0x006, 0x000, 0x001, 0x005, 0x00B, 0x000, 0x00D, 0x012, 0x005, 0x002,
-    0x004, 0x000, 0x005, 0x00B, 0x000, 0x007, 0x004, 0x001, 0x003, 0x008, 0x003, 0x002, 0x005,
-    0x001, 0x000, 0x002, 0x002, 0x000, 0x000, 0x001, 0x002, 0x000, 0x001, 0x000, 0x000, 0x001,
-    0x008, 0x003, 0x000, 0x000, 0x000, 0x000, 0x002, 0x008, 0x000, 0x002, 0x000, 0x001, 0x00E,
-    0x000, 0x000, 0x003, 0x002, 0x006, 0x000, 0x001, 0x008, 0x002, 0x005, 0x000, 0x001, 0x001,
-    0x007, 0x006, 0x001, 0x000, 0x000, 0x000, 0x002, 0x000, 0x000, 0x002, 0x001, 0x001, 0x005,
-    0x000, 0x003, 0x009, 0x002, 0x000, 0x001, 0x000, 0x009, 0x001, 0x001, 0x002, 0x001, 0x002,
-    0x003, 0x002, 0x000, 0x000, 0x000, 0x006, 0x001, 0x000, 0x001, 0x006, 0x000, 0x000, 0x000,
-    0x000, 0x001, 0x000, 0x000, 0x001, 0x001, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x001,
-    0x014, 0x000, 0x000, 0x000, 0x001, 0x000, 0x006, 0x001, 0x000, 0x000, 0x012, 0x000, 0x004,
-    0x012, 0x003, 0x004, 0x002, 0x000, 0x000, 0x000, 0x005, 0x006, 0x000, 0x001, 0x001, 0x000,
-    0x000, 0x006, 0x002, 0x004, 0x004, 0x002, 0x000, 0x000, 0x002, 0x001, 0x001, 0x000, 0x001,
-    0x00B, 0x000, 0x006, 0x000, 0x000, 0x000, 0x002, 0x001, 0x009, 0x001, 0x002, 0x010, 0x001,
-    0x002, 0x002, 0x001, 0x000, 0x001, 0x00F, 0x009, 0x001, 0x001, 0x000, 0x000, 0x001, 0x001,
-    0x001, 0x000, 0x000, 0x000, 0x002, 0x000, 0x002, 0x000, 0x000, 0x000, 0x003, 0x001, 0x007,
-    0x00F, 0x005, 0x005, 0x000, 0x000, 0x000, 0x001, 0x004, 0x000, 0x002, 0x004, 0x003, 0x001,
-    0x001, 0x002, 0x004, 0x001, 0x002, 0x001, 0x002, 0x002, 0x009, 0x000, 0x001, 0x000, 0x005,
-    0x00B, 0x001, 0x000, 0x002, 0x00B, 0x000, 0x004, 0x000, 0x001, 0x001, 0x001, 0x000, 0x009,
-    0x002, 0x005, 0x000, 0x004, 0x003, 0x002, 0x001, 0x001, 0x002, 0x000, 0x006, 0x00A, 0x000,
-    0x002, 0x001, 0x009, 0x001, 0x001, 0x001, 0x008, 0x001, 0x002, 0x001, 0x001, 0x000, 0x001,
-    0x003, 0x001, 0x001, 0x001, 0x003, 0x001, 0x005, 0x001, 0x003, 0x001, 0x000, 0x000, 0x006,
-    0x000, 0x004, 0x001, 0x003, 0x001, 0x003, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x00B, 0x000, 0x000, 0x000, 0x000, 0x000, 0x003, 0x006, 0x000, 0x000,
-    0x002, 0x003, 0x003, 0x002, 0x002, 0x000, 0x004, 0x002, 0x000, 0x001, 0x001, 0x00A, 0x003,
-    0x000, 0x003, 0x004, 0x001, 0x001, 0x003, 0x000, 0x000, 0x004, 0x004, 0x001, 0x002, 0x005,
-    0x00C, 0x001, 0x000, 0x007, 0x002, 0x001, 0x002, 0x005, 0x001, 0x000, 0x004, 0x001, 0x000,
-    0x000, 0x001, 0x000, 0x000, 0x00B, 0x00D, 0x002, 0x003, 0x000, 0x000, 0x000, 0x000, 0x005,
-    0x005, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x006, 0x002, 0x002,
-    0x002, 0x001, 0x001, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x001, 0x00B, 0x001, 0x001,
-    0x001, 0x002, 0x005, 0x001, 0x001, 0x003, 0x004, 0x001, 0x002, 0x002, 0x008, 0x000, 0x001,
-    0x004, 0x003, 0x003, 0x001, 0x008, 0x001, 0x008, 0x001, 0x000, 0x004, 0x008, 0x000, 0x002,
-    0x003, 0x003, 0x000, 0x000, 0x002, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x004, 0x000, 0x000, 0x000, 0x00A, 0x000, 0x001, 0x000, 0x000, 0x000, 0x001, 0x003, 0x009,
-    0x000, 0x002, 0x001, 0x00A, 0x000, 0x001, 0x000, 0x000, 0x003, 0x000, 0x001, 0x001, 0x000,
-    0x009, 0x007, 0x001, 0x002, 0x008, 0x001, 0x005, 0x003, 0x002, 0x001, 0x001, 0x002, 0x002,
-    0x001, 0x001, 0x001, 0x005, 0x000, 0x000, 0x001, 0x000, 0x00A, 0x003, 0x000, 0x000, 0x001,
-    0x000, 0x00C, 0x000, 0x007, 0x003, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x003,
-    0x001, 0x000, 0x001, 0x004, 0x00F, 0x000, 0x001, 0x000, 0x001, 0x000, 0x000, 0x000, 0x008,
-    0x000, 0x002, 0x006, 0x001, 0x000, 0x004, 0x002, 0x000, 0x001, 0x004, 0x000, 0x002, 0x002,
-    0x002, 0x001, 0x000, 0x000, 0x002, 0x001, 0x000, 0x003, 0x001, 0x000, 0x001, 0x000, 0x001,
-    0x001, 0x002, 0x002, 0x002, 0x00A, 0x001, 0x001, 0x001, 0x001, 0x002, 0x002, 0x000, 0x001,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x002, 0x008, 0x001, 0x002, 0x006, 0x001, 0x000,
-    0x002, 0x001, 0x000, 0x000, 0x000, 0x001, 0x002, 0x001, 0x004, 0x004, 0x001, 0x000, 0x005,
-    0x001, 0x001, 0x001, 0x000, 0x002, 0x001, 0x000, 0x000, 0x000, 0x002, 0x000, 0x001, 0x000,
-    0x000, 0x001, 0x004, 0x000, 0x009, 0x002, 0x00C, 0x008, 0x000, 0x001, 0x000, 0x004, 0x000,
-    0x000, 0x001, 0x003, 0x004, 0x002, 0x000, 0x001, 0x003, 0x004, 0x000, 0x001, 0x000, 0x007,
-    0x002, 0x001, 0x004, 0x000, 0x004, 0x000, 0x000, 0x000, 0x000, 0x000, 0x009, 0x001, 0x001,
-    0x002, 0x000, 0x004, 0x001, 0x001, 0x001, 0x000, 0x001, 0x001, 0x001, 0x001, 0x000, 0x000,
-    0x001, 0x001, 0x003, 0x001, 0x001, 0x001, 0x002, 0x000, 0x003, 0x001, 0x000, 0x002, 0x000,
-    0x004, 0x001, 0x000, 0x000, 0x000, 0x001, 0x007, 0x000, 0x000, 0x000, 0x000, 0x004, 0x000,
-    0x001, 0x007, 0x000, 0x000, 0x000, 0x001, 0x004, 0x001, 0x000, 0x004, 0x002, 0x002, 0x001,
-    0x000, 0x001, 0x001, 0x001, 0x002, 0x001, 0x000, 0x007, 0x000, 0x000, 0x006, 0x000, 0x003,
-    0x002, 0x002, 0x001, 0x000, 0x000, 0x002, 0x000, 0x001, 0x003, 0x005, 0x001, 0x001, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x006, 0x001, 0x001, 0x003, 0x009, 0x000, 0x001, 0x001,
-    0x000, 0x006, 0x000, 0x003, 0x001, 0x002, 0x000, 0x001, 0x002, 0x005, 0x005, 0x002, 0x000,
-    0x001, 0x004, 0x000, 0x001, 0x001, 0x001, 0x001, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000,
-    0x002, 0x000, 0x000, 0x001, 0x002, 0x001, 0x000, 0x000, 0x002, 0x000, 0x001, 0x006, 0x006,
-    0x002, 0x002, 0x000, 0x003, 0x002, 0x003, 0x001, 0x001, 0x002, 0x001, 0x002, 0x00B, 0x000,
-    0x001, 0x000, 0x001, 0x002, 0x002, 0x004, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000,
-    0x000, 0x000, 0x003, 0x000, 0x000, 0x001, 0x006, 0x000, 0x002, 0x001, 0x000, 0x003, 0x004,
-    0x000, 0x003, 0x000, 0x001, 0x004, 0x001, 0x003, 0x002, 0x000, 0x000, 0x002, 0x001, 0x000,
-    0x001, 0x001, 0x001, 0x005, 0x006, 0x004, 0x000, 0x000, 0x000, 0x002, 0x001, 0x000, 0x001,
-    0x001, 0x004, 0x001, 0x001, 0x009, 0x000, 0x002, 0x000, 0x002, 0x003, 0x005, 0x002, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x001, 0x003,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x002, 0x007, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x000, 0x00A, 0x001, 0x000, 0x001, 0x010, 0x002, 0x008, 0x001, 0x001, 0x002, 0x001, 0x002,
-    0x001, 0x000, 0x003, 0x002, 0x004, 0x000, 0x002, 0x002, 0x000, 0x001, 0x002, 0x001, 0x001,
-    0x001, 0x001, 0x000, 0x000, 0x000, 0x006, 0x002, 0x005, 0x000, 0x000, 0x004, 0x004, 0x001,
-    0x005, 0x000, 0x005, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x001, 0x000,
-    0x005, 0x000, 0x000, 0x000, 0x005, 0x002, 0x001, 0x003, 0x009, 0x001, 0x003, 0x000, 0x000,
-    0x002, 0x000, 0x001, 0x001, 0x004, 0x002, 0x000, 0x008, 0x002, 0x001, 0x006, 0x000, 0x002,
-    0x002, 0x003, 0x000, 0x003, 0x001, 0x001, 0x002, 0x002, 0x000, 0x003, 0x001, 0x000, 0x000,
-    0x000, 0x002, 0x002, 0x000, 0x002, 0x005, 0x001, 0x000, 0x000, 0x000, 0x002, 0x002, 0x001,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000,
-    0x000, 0x001, 0x000, 0x007, 0x001, 0x000, 0x002, 0x002, 0x000, 0x001, 0x000, 0x002, 0x000,
-    0x006, 0x002, 0x001, 0x008, 0x000, 0x002, 0x002, 0x001, 0x004, 0x001, 0x000, 0x001, 0x001,
-    0x002, 0x009, 0x001, 0x001, 0x001, 0x004, 0x001, 0x005, 0x002, 0x001, 0x001, 0x004, 0x003,
-    0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x000, 0x001, 0x000, 0x001, 0x001, 0x000, 0x004,
-    0x004,
-];
-pub(crate) const CANONICAL_DECOMPOSED_KV: &[(u32, (u16, u16))] = &[
-    (0x2F93B, (0xC97, 0x1)),
-    (0x2F869, (0xBC5, 0x1)),
-    (0x0F93E, (0x91F, 0x1)),
-    (0x01F2E, (0x60A, 0x3)),
-    (0x2F90A, (0xC66, 0x1)),
-    (0x0FACB, (0xA9E, 0x1)),
-    (0x0FA87, (0xA5A, 0x1)),
-    (0x2F95B, (0xCB7, 0x1)),
-    (0x0F965, (0x946, 0x1)),
-    (0x2F8FB, (0xC57, 0x1)),
-    (0x2F83A, (0xB96, 0x1)),
-    (0x0095B, (0x2CA, 0x2)),
-    (0x01FAF, (0x775, 0x4)),
-    (0x2F92C, (0xC88, 0x1)),
-    (0x01E88, (0x482, 0x2)),
-    (0x009CB, (0x2D4, 0x2)),
-    (0x01F0A, (0x5B2, 0x3)),
-    (0x00229, (0x1F2, 0x2)),
-    (0x0FA8B, (0xA5E, 0x1)),
-    (0x2F8FD, (0xC59, 0x1)),
-    (0x2F9AD, (0xD09, 0x1)),
-    (0x01E7A, (0x464, 0x3)),
-    (0x0F994, (0x975, 0x1)),
-    (0x2F9EF, (0xD4B, 0x1)),
-    (0x2F8CE, (0xC2A, 0x1)),
-    (0x003AF, (0x233, 0x2)),
-    (0x00211, (0x1D2, 0x2)),
-    (0x0F9C8, (0x9A9, 0x1)),
-    (0x0FA95, (0xA68, 0x1)),
-    (0x2F9C0, (0xD1C, 0x1)),
-    (0x01EA9, (0x4BF, 0x3)),
-    (0x000F5, (0x05A, 0x2)),
-    (0x2F833, (0xB8F, 0x1)),
-    (0x0F94A, (0x92B, 0x1)),
-    (0x0F96C, (0x94D, 0x1)),
-    (0x0FA3E, (0xA13, 0x1)),
-    (0x0FA5E, (0xA33, 0x1)),
-    (0x01E72, (0x452, 0x2)),
-    (0x0FA1E, (0x9FA, 0x1)),
-    (0x0015F, (0x106, 0x2)),
-    (0x01F64, (0x687, 0x3)),
-    (0x01F07, (0x5AB, 0x3)),
-    (0x01E87, (0x480, 0x2)),
-    (0x0FA86, (0xA59, 0x1)),
-    (0x0F92F, (0x910, 0x1)),
-    (0x2F8DD, (0xC39, 0x1)),
-    (0x2FA17, (0xD73, 0x1)),
-    (0x00F73, (0x324, 0x2)),
-    (0x01ED0, (0x526, 0x3)),
-    (0x0F9CA, (0x9AB, 0x1)),
-    (0x113C8, (0xB11, 0x2)),
-    (0x2F83F, (0xB9B, 0x1)),
-    (0x2F999, (0xCF5, 0x1)),
-    (0x2F9F6, (0xD52, 0x1)),
-    (0x01FC2, (0x797, 0x3)),
-    (0x0FABC, (0xA8F, 0x1)),
-    (0x01FDA, (0x7C7, 0x2)),
-    (0x2F9B9, (0xD15, 0x1)),
-    (0x0F9F5, (0x9D6, 0x1)),
-    (0x01E73, (0x454, 0x2)),
-    (0x0FA9D, (0xA70, 0x1)),
-    (0x01E29, (0x3AC, 0x2)),
-    (0x0FA5F, (0xA34, 0x1)),
-    (0x2F849, (0xBA5, 0x1)),
-    (0x00F43, (0x318, 0x2)),
-    (0x01EA2, (0x4AC, 0x2)),
-    (0x0F99C, (0x97D, 0x1)),
-    (0x00129, (0x0B4, 0x2)),
-    (0x01F85, (0x6D7, 0x4)),
-    (0x2F8C0, (0xC1C, 0x1)),
-    (0x01E93, (0x498, 0x2)),
-    (0x02280, (0x845, 0x2)),
-    (0x2F821, (0xB7D, 0x1)),
-    (0x0FA50, (0xA25, 0x1)),
-    (0x03077, (0x895, 0x2)),
-    (0x001FD, (0x1AA, 0x2)),
-    (0x00230, (0x204, 0x3)),
-    (0x0016D, (0x11E, 0x2)),
-    (0x0F9A2, (0x983, 0x1)),
-    (0x01EA8, (0x4BC, 0x3)),
-    (0x1D161, (0xB40, 0x3)),
-    (0x0FA94, (0xA67, 0x1)),
-    (0x01F1A, (0x5D8, 0x3)),
-    (0x001A1, (0x144, 0x2)),
-    (0x2F922, (0xC7E, 0x1)),
-    (0x01FF9, (0x802, 0x2)),
-    (0x0F93D, (0x91E, 0x1)),
-    (0x030AC, (0x8A3, 0x2)),
-    (0x0F9E9, (0x9CA, 0x1)),
-    (0x01E89, (0x484, 0x2)),
-    (0x01F35, (0x61D, 0x3)),
-    (0x0FA2F, (0xA04, 0x1)),
-    (0x0F90A, (0x8EB, 0x1)),
-    (0x0F9FC, (0x9DD, 0x1)),
-    (0x2F891, (0xBED, 0x1)),
-    (0x0307D, (0x89D, 0x2)),
-    (0x01FA5, (0x74F, 0x4)),
-    (0x00173, (0x12A, 0x2)),
-    (0x0FB49, (0xAE7, 0x2)),
-    (0x0FACA, (0xA9D, 0x1)),
-    (0x0F97B, (0x95C, 0x1)),
-    (0x2F9FD, (0xD59, 0x1)),
-    (0x2F90B, (0xC67, 0x1)),
-    (0x0F9A3, (0x984, 0x1)),
-    (0x01E2A, (0x3AE, 0x2)),
-    (0x01FBB, (0x790, 0x2)),
-    (0x2F9A0, (0xCFC, 0x1)),
-    (0x0F924, (0x905, 0x1)),
-    (0x01E7B, (0x467, 0x3)),
-    (0x2F8CB, (0xC27, 0x1)),
-    (0x2F8F6, (0xC52, 0x1)),
-    (0x004F1, (0x2A0, 0x2)),
-    (0x01FD0, (0x7B4, 0x2)),
-    (0x01EF5, (0x58E, 0x2)),
-    (0x00146, (0x0DE, 0x2)),
-    (0x01E2E, (0x3B6, 0x3)),
-    (0x0F95E, (0x93F, 0x1)),
-    (0x0F916, (0x8F7, 0x1)),
-    (0x0FA44, (0xA19, 0x1)),
-    (0x0FA16, (0x9F2, 0x1)),
-    (0x01F1C, (0x5DE, 0x3)),
-    (0x105E4, (0xAF5, 0x2)),
-    (0x2F94D, (0xCA9, 0x1)),
-    (0x0FAB9, (0xA8C, 0x1)),
-    (0x0F907, (0x8E8, 0x1)),
-    (0x0305E, (0x87F, 0x2)),
-    (0x01E0D, (0x36E, 0x2)),
-    (0x01F4A, (0x650, 0x3)),
-    (0x0F9F9, (0x9DA, 0x1)),
-    (0x2F9C7, (0xD23, 0x1)),
-    (0x0F94B, (0x92C, 0x1)),
-    (0x2F87E, (0xBDA, 0x1)),
-    (0x00D4C, (0x30D, 0x2)),
-    (0x0F9EC, (0x9CD, 0x1)),
-    (0x001AF, (0x146, 0x2)),
-    (0x2F91D, (0xC79, 0x1)),
-    (0x01EE8, (0x56A, 0x3)),
-    (0x022AD, (0x853, 0x2)),
-    (0x2F834, (0xB90, 0x1)),
-    (0x01EC8, (0x516, 0x2)),
-    (0x01F52, (0x660, 0x3)),
-    (0x2F84F, (0xBAB, 0x1)),
-    (0x01E27, (0x3A8, 0x2)),
-    (0x01F48, (0x64C, 0x2)),
-    (0x01FEB, (0x7EA, 0x2)),
-    (0x0F9C4, (0x9A5, 0x1)),
-    (0x01EE5, (0x564, 0x2)),
-    (0x01EBB, (0x4F2, 0x2)),
-    (0x0F9B5, (0x996, 0x1)),
-    (0x01F8D, (0x6F5, 0x4)),
-    (0x01EAF, (0x4D1, 0x3)),
-    (0x0FA78, (0xA4B, 0x1)),
-    (0x2F975, (0xCD1, 0x1)),
-    (0x2F9BA, (0xD16, 0x1)),
-    (0x01E22, (0x39E, 0x2)),
-    (0x01EEA, (0x570, 0x3)),
-    (0x0FB2A, (0xAB1, 0x2)),
-    (0x2F951, (0xCAD, 0x1)),
-    (0x00A33, (0x2DE, 0x2)),
-    (0x2F8DC, (0xC38, 0x1)),
-    (0x000E7, (0x040, 0x2)),
-    (0x2F8F7, (0xC53, 0x1)),
-    (0x2F9EB, (0xD47, 0x1)),
-    (0x00174, (0x12C, 0x2)),
-    (0x0011D, (0x0A0, 0x2)),
-    (0x0F966, (0x947, 0x1)),
-    (0x0FB36, (0xACB, 0x2)),
-    (0x2F88A, (0xBE6, 0x1)),
-    (0x00450, (0x258, 0x2)),
-    (0x0305C, (0x87D, 0x2)),
-    (0x0F9F6, (0x9D7, 0x1)),
-    (0x0F9A7, (0x988, 0x1)),
-    (0x0FA82, (0xA55, 0x1)),
-    (0x0FAD7, (0xAAA, 0x1)),
-    (0x01B41, (0x34E, 0x2)),
-    (0x01E5D, (0x421, 0x3)),
-    (0x01F12, (0x5C8, 0x3)),
-    (0x00108, (0x07A, 0x2)),
-    (0x01EAC, (0x4C8, 0x3)),
-    (0x2F9F0, (0xD4C, 0x1)),
-    (0x00100, (0x06A, 0x2)),
-    (0x0FAA2, (0xA75, 0x1)),
-    (0x003D3, (0x242, 0x2)),
-    (0x0F973, (0x954, 0x1)),
-    (0x00407, (0x24C, 0x2)),
-    (0x03070, (0x88B, 0x2)),
-    (0x01E79, (0x461, 0x3)),
-    (0x0F964, (0x945, 0x1)),
-    (0x00F52, (0x31C, 0x2)),
-    (0x0F9EF, (0x9D0, 0x1)),
-    (0x01E58, (0x416, 0x2)),
-    (0x2F949, (0xCA5, 0x1)),
-    (0x00171, (0x126, 0x2)),
-    (0x01F2A, (0x5FE, 0x3)),
-    (0x00388, (0x21A, 0x2)),
-    (0x00157, (0x0F6, 0x2)),
-    (0x01F3D, (0x633, 0x3)),
-    (0x0F98B, (0x96C, 0x1)),
-    (0x030BE, (0x8B5, 0x2)),
-    (0x2F816, (0xB72, 0x1)),
-    (0x01E95, (0x49C, 0x2)),
-    (0x0F991, (0x972, 0x1)),
-    (0x2F8B5, (0xC11, 0x1)),
-    (0x2F810, (0xB6C, 0x1)),
-    (0x0FAB8, (0xA8B, 0x1)),
-    (0x001EC, (0x18E, 0x3)),
-    (0x01E09, (0x365, 0x3)),
-    (0x2F8BB, (0xC17, 0x1)),
-    (0x2F9E1, (0xD3D, 0x1)),
-    (0x2F94E, (0xCAA, 0x1)),
-    (0x01FAE, (0x771, 0x4)),
-    (0x01FFD, (0x80A, 0x1)),
-    (0x0FA00, (0x9E1, 0x1)),
-    (0x00BCC, (0x2FA, 0x2)),
-    (0x0FA4B, (0xA20, 0x1)),
-    (0x0FAC3, (0xA96, 0x1)),
-    (0x021CE, (0x819, 0x2)),
-    (0x02271, (0x83B, 0x2)),
-    (0x000CB, (0x014, 0x2)),
-    (0x01F51, (0x65E, 0x2)),
-    (0x0FA99, (0xA6C, 0x1)),
-    (0x030B8, (0x8AF, 0x2)),
-    (0x01E7E, (0x46E, 0x2)),
-    (0x0FA75, (0xA48, 0x1)),
-    (0x16128, (0xB2F, 0x3)),
-    (0x0F978, (0x959, 0x1)),
-    (0x001E6, (0x182, 0x2)),
-    (0x01E8E, (0x48E, 0x2)),
-    (0x2F9E6, (0xD42, 0x1)),
-    (0x2F8E3, (0xC3F, 0x1)),
-    (0x0045D, (0x262, 0x2)),
-    (0x001DE, (0x172, 0x3)),
-    (0x01F63, (0x684, 0x3)),
-    (0x01E48, (0x3EE, 0x2)),
-    (0x2F8D0, (0xC2C, 0x1)),
-    (0x0FA22, (0x9FC, 0x1)),
-    (0x0FACF, (0xAA2, 0x1)),
-    (0x01EA3, (0x4AE, 0x2)),
-    (0x022E3, (0x85F, 0x2)),
-    (0x0FAD4, (0xAA7, 0x1)),
-    (0x0304C, (0x86D, 0x2)),
-    (0x0FA8D, (0xA60, 0x1)),
-    (0x004D6, (0x276, 0x2)),
-    (0x01F00, (0x598, 0x2)),
-    (0x0FA36, (0xA0B, 0x1)),
-    (0x0FA72, (0xA45, 0x1)),
-    (0x2F9A3, (0xCFF, 0x1)),
-    (0x01F1B, (0x5DB, 0x3)),
-    (0x01F5D, (0x677, 0x3)),
-    (0x2F9AB, (0xD07, 0x1)),
-    (0x0FA15, (0x9F1, 0x1)),
-    (0x0F9BE, (0x99F, 0x1)),
-    (0x1D1BF, (0xB56, 0x3)),
-    (0x0010D, (0x084, 0x2)),
-    (0x01FB4, (0x782, 0x3)),
-    (0x0F942, (0x923, 0x1)),
-    (0x00934, (0x2C2, 0x2)),
-    (0x0FAAE, (0xA81, 0x1)),
-    (0x2F98A, (0xCE6, 0x1)),
-    (0x01F3C, (0x630, 0x3)),
-    (0x2F9D1, (0xD2D, 0x1)),
-    (0x01FD9, (0x7C5, 0x2)),
-    (0x01F38, (0x626, 0x2)),
-    (0x030BC, (0x8B3, 0x2)),
-    (0x000FC, (0x064, 0x2)),
-    (0x01F05, (0x5A5, 0x3)),
-    (0x01EE4, (0x562, 0x2)),
-    (0x0F90C, (0x8ED, 0x1)),
-    (0x01EB3, (0x4DD, 0x3)),
-    (0x2F8E0, (0xC3C, 0x1)),
-    (0x0016B, (0x11A, 0x2)),
-    (0x01E12, (0x378, 0x2)),
-    (0x0F99F, (0x980, 0x1)),
-    (0x01FB3, (0x780, 0x2)),
-    (0x1D160, (0xB3D, 0x3)),
-    (0x000CF, (0x01C, 0x2)),
-    (0x000CD, (0x018, 0x2)),
-    (0x2F835, (0xB91, 0x1)),
-    (0x0F902, (0x8E3, 0x1)),
-    (0x00B4C, (0x2EE, 0x2)),
-    (0x2F99C, (0xCF8, 0x1)),
-    (0x0FA41, (0xA16, 0x1)),
-    (0x0F9C5, (0x9A6, 0x1)),
-    (0x0F9C7, (0x9A8, 0x1)),
-    (0x030FE, (0x8DF, 0x2)),
-    (0x01EE0, (0x556, 0x3)),
-    (0x2F882, (0xBDE, 0x1)),
-    (0x2F973, (0xCCF, 0x1)),
-    (0x0FA0D, (0x9EE, 0x1)),
-    (0x0FA5C, (0xA31, 0x1)),
-    (0x2F900, (0xC5C, 0x1)),
-    (0x0F9FD, (0x9DE, 0x1)),
-    (0x01F62, (0x681, 0x3)),
-    (0x2F8B9, (0xC15, 0x1)),
-    (0x001F5, (0x19C, 0x2)),
-    (0x01EF3, (0x58A, 0x2)),
-    (0x2F84C, (0xBA8, 0x1)),
-    (0x001D5, (0x15A, 0x3)),
-    (0x0F9BC, (0x99D, 0x1)),
-    (0x01FE5, (0x7DD, 0x2)),
-    (0x01F5B, (0x674, 0x3)),
-    (0x03071, (0x88D, 0x2)),
-    (0x2F9BB, (0xD17, 0x1)),
-    (0x01FAA, (0x761, 0x4)),
-    (0x01F94, (0x70F, 0x4)),
-    (0x01E4E, (0x3FC, 0x3)),
-    (0x001EE, (0x194, 0x2)),
-    (0x0F9ED, (0x9CE, 0x1)),
-    (0x2F9B4, (0xD10, 0x1)),
-    (0x2FA0F, (0xD6B, 0x1)),
-    (0x00DDE, (0x316, 0x2)),
-    (0x0F915, (0x8F6, 0x1)),
-    (0x01F87, (0x6DF, 0x4)),
-    (0x0F9B2, (0x993, 0x1)),
-    (0x01B06, (0x33C, 0x2)),
-    (0x2F84B, (0xBA7, 0x1)),
-    (0x2F93D, (0xC99, 0x1)),
-    (0x00113, (0x08C, 0x2)),
-    (0x01F69, (0x695, 0x2)),
-    (0x2F8C6, (0xC22, 0x1)),
-    (0x000FF, (0x068, 0x2)),
-    (0x01E77, (0x45C, 0x2)),
-    (0x2FA12, (0xD6E, 0x1)),
-    (0x00341, (0x20F, 0x1)),
-    (0x2F827, (0xB83, 0x1)),
-    (0x01B43, (0x350, 0x2)),
-    (0x2F8BA, (0xC16, 0x1)),
-    (0x0F987, (0x968, 0x1)),
-    (0x01B12, (0x346, 0x2)),
-    (0x022EA, (0x861, 0x2)),
-    (0x2F97D, (0xCD9, 0x1)),
-    (0x16D68, (0xB32, 0x2)),
-    (0x0FB4C, (0xAED, 0x2)),
-    (0x01E4A, (0x3F2, 0x2)),
-    (0x01E1E, (0x396, 0x2)),
-    (0x00B48, (0x2EA, 0x2)),
-    (0x009DC, (0x2D8, 0x2)),
-    (0x000DD, (0x032, 0x2)),
-    (0x2F971, (0xCCD, 0x1)),
-    (0x0FA9F, (0xA72, 0x1)),
-    (0x0045E, (0x264, 0x2)),
-    (0x01FA3, (0x747, 0x4)),
-    (0x004DF, (0x284, 0x2)),
-    (0x004DC, (0x27E, 0x2)),
-    (0x00150, (0x0EC, 0x2)),
-    (0x000DA, (0x02C, 0x2)),
-    (0x001E7, (0x184, 0x2)),
-    (0x2F92E, (0xC8A, 0x1)),
-    (0x0F918, (0x8F9, 0x1)),
-    (0x01FCE, (0x7B0, 0x2)),
-    (0x0232A, (0x86A, 0x1)),
-    (0x02281, (0x847, 0x2)),
-    (0x01E0F, (0x372, 0x2)),
-    (0x000E3, (0x03A, 0x2)),
-    (0x0FB48, (0xAE5, 0x2)),
-    (0x2FA0B, (0xD67, 0x1)),
-    (0x0FB1D, (0xAAD, 0x2)),
-    (0x01E90, (0x492, 0x2)),
-    (0x003AA, (0x229, 0x2)),
-    (0x0F981, (0x962, 0x1)),
-    (0x01E30, (0x3BC, 0x2)),
-    (0x01EBD, (0x4F6, 0x2)),
-    (0x01E0B, (0x36A, 0x2)),
-    (0x01E62, (0x42C, 0x2)),
-    (0x2F85D, (0xBB9, 0x1)),
-    (0x00401, (0x248, 0x2)),
-    (0x2F87F, (0xBDB, 0x1)),
-    (0x01F22, (0x5E8, 0x3)),
-    (0x2F9A4, (0xD00, 0x1)),
-    (0x2F855, (0xBB1, 0x1)),
-    (0x2F98F, (0xCEB, 0x1)),
-    (0x0F9D0, (0x9B1, 0x1)),
-    (0x021CD, (0x817, 0x2)),
-    (0x2F87A, (0xBD6, 0x1)),
-    (0x01FB9, (0x78C, 0x2)),
-    (0x2F8C8, (0xC24, 0x1)),
-    (0x0FA65, (0xA3A, 0x1)),
-    (0x01EA4, (0x4B0, 0x3)),
-    (0x0014C, (0x0E4, 0x2)),
-    (0x004F0, (0x29E, 0x2)),
-    (0x01FB0, (0x779, 0x2)),
-    (0x01FAD, (0x76D, 0x4)),
-    (0x2F94F, (0xCAB, 0x1)),
-    (0x01F75, (0x6B3, 0x2)),
-    (0x0F905, (0x8E6, 0x1)),
-    (0x0FA71, (0xA44, 0x1)),
-    (0x000CE, (0x01A, 0x2)),
-    (0x2F89E, (0xBFA, 0x1)),
-    (0x2F903, (0xC5F, 0x1)),
-    (0x0F939, (0x91A, 0x1)),
-    (0x00B94, (0x2F4, 0x2)),
-    (0x2F926, (0xC82, 0x1)),
-    (0x0FA20, (0x9FB, 0x1)),
-    (0x01EAB, (0x4C5, 0x3)),
-    (0x004EF, (0x29C, 0x2)),
-    (0x01F4D, (0x659, 0x3)),
-    (0x1134B, (0xB01, 0x2)),
-    (0x01F28, (0x5FA, 0x2)),
-    (0x2F955, (0xCB1, 0x1)),
-    (0x01FBC, (0x792, 0x2)),
-    (0x01E42, (0x3E2, 0x2)),
-    (0x0F935, (0x916, 0x1)),
-    (0x114BB, (0xB13, 0x2)),
-    (0x2F9E0, (0xD3C, 0x1)),
-    (0x0015E, (0x104, 0x2)),
-    (0x0017B, (0x13A, 0x2)),
-    (0x01E3B, (0x3D4, 0x2)),
-    (0x01E6A, (0x442, 0x2)),
-    (0x00214, (0x1D8, 0x2)),
-    (0x01B0A, (0x340, 0x2)),
-    (0x2F825, (0xB81, 0x1)),
-    (0x01E78, (0x45E, 0x3)),
-    (0x001E8, (0x186, 0x2)),
-    (0x022ED, (0x867, 0x2)),
-    (0x00387, (0x219, 0x1)),
-    (0x2F9CE, (0xD2A, 0x1)),
-    (0x2F984, (0xCE0, 0x1)),
-    (0x022EB, (0x863, 0x2)),
-    (0x01FCB, (0x7AA, 0x2)),
-    (0x0FAC5, (0xA98, 0x1)),
-    (0x2F806, (0xB62, 0x1)),
-    (0x0F960, (0x941, 0x1)),
-    (0x0F9B3, (0x994, 0x1)),
-    (0x0FA02, (0x9E3, 0x1)),
-    (0x01EB9, (0x4EE, 0x2)),
-    (0x01F3E, (0x636, 0x3)),
-    (0x01EB1, (0x4D7, 0x3)),
-    (0x2FA15, (0xD71, 0x1)),
-    (0x0FB31, (0xAC1, 0x2)),
-    (0x01F0D, (0x5BB, 0x3)),
-    (0x0F9AB, (0x98C, 0x1)),
-    (0x0FB39, (0xACF, 0x2)),
-    (0x0305A, (0x87B, 0x2)),
-    (0x0F9B0, (0x991, 0x1)),
-    (0x0F91A, (0x8FB, 0x1)),
-    (0x2F9F8, (0xD54, 0x1)),
-    (0x2F977, (0xCD3, 0x1)),
-    (0x001CF, (0x14E, 0x2)),
-    (0x01E20, (0x39A, 0x2)),
-    (0x0F9A4, (0x985, 0x1)),
-    (0x00176, (0x130, 0x2)),
-    (0x2FA1D, (0xD79, 0x1)),
-    (0x004F4, (0x2A6, 0x2)),
-    (0x2FA10, (0xD6C, 0x1)),
-    (0x0F96E, (0x94F, 0x1)),
-    (0x0F9BF, (0x9A0, 0x1)),
-    (0x01F9E, (0x735, 0x4)),
-    (0x2F84D, (0xBA9, 0x1)),
-    (0x2FA0E, (0xD6A, 0x1)),
-    (0x0FA07, (0x9E8, 0x1)),
-    (0x004E7, (0x290, 0x2)),
-    (0x01FE3, (0x7D8, 0x3)),
-    (0x003CC, (0x23C, 0x2)),
-    (0x01FA6, (0x753, 0x4)),
-    (0x0020F, (0x1CE, 0x2)),
-    (0x0FA5D, (0xA32, 0x1)),
-    (0x00107, (0x078, 0x2)),
-    (0x0FA4F, (0xA24, 0x1)),
-    (0x0FA64, (0xA39, 0x1)),
-    (0x1D1BC, (0xB4E, 0x2)),
-    (0x0F99A, (0x97B, 0x1)),
-    (0x2F9D5, (0xD31, 0x1)),
-    (0x01EA7, (0x4B9, 0x3)),
-    (0x2F8F9, (0xC55, 0x1)),
-    (0x0F9F0, (0x9D1, 0x1)),
-    (0x00476, (0x266, 0x2)),
-    (0x000EA, (0x046, 0x2)),
-    (0x2F86F, (0xBCB, 0x1)),
-    (0x2F992, (0xCEE, 0x1)),
-    (0x01E0E, (0x370, 0x2)),
-    (0x0F95D, (0x93E, 0x1)),
-    (0x0FA89, (0xA5C, 0x1)),
-    (0x0022F, (0x202, 0x2)),
-    (0x00CCB, (0x306, 0x3)),
-    (0x2F841, (0xB9D, 0x1)),
-    (0x004E6, (0x28E, 0x2)),
-    (0x01E5F, (0x426, 0x2)),
-    (0x004C2, (0x26C, 0x2)),
-    (0x004EC, (0x296, 0x2)),
-    (0x01B0E, (0x344, 0x2)),
-    (0x00390, (0x226, 0x3)),
-    (0x00105, (0x074, 0x2)),
-    (0x00419, (0x254, 0x2)),
-    (0x0F959, (0x93A, 0x1)),
-    (0x030F8, (0x8D9, 0x2)),
-    (0x01F25, (0x5F1, 0x3)),
-    (0x01EC0, (0x4FE, 0x3)),
-    (0x00124, (0x0AE, 0x2)),
-    (0x00101, (0x06C, 0x2)),
-    (0x000C7, (0x00C, 0x2)),
-    (0x2F9FC, (0xD58, 0x1)),
-    (0x0F92E, (0x90F, 0x1)),
-    (0x2F910, (0xC6C, 0x1)),
-    (0x02284, (0x849, 0x2)),
-    (0x01EE3, (0x55F, 0x3)),
-    (0x01E34, (0x3C4, 0x2)),
-    (0x003AD, (0x22F, 0x2)),
-    (0x0FA2C, (0xA01, 0x1)),
-    (0x2F877, (0xBD3, 0x1)),
-    (0x0F99B, (0x97C, 0x1)),
-    (0x000E8, (0x042, 0x2)),
-    (0x01E28, (0x3AA, 0x2)),
-    (0x01EA1, (0x4AA, 0x2)),
-    (0x2F94A, (0xCA6, 0x1)),
-    (0x1D15E, (0xB39, 0x2)),
-    (0x2F83B, (0xB97, 0x1)),
-    (0x1D164, (0xB49, 0x3)),
-    (0x2F854, (0xBB0, 0x1)),
-    (0x2F892, (0xBEE, 0x1)),
-    (0x1D1BB, (0xB4C, 0x2)),
-    (0x0010F, (0x088, 0x2)),
-    (0x01E63, (0x42E, 0x2)),
-    (0x01FD3, (0x7BB, 0x3)),
-    (0x01FB6, (0x785, 0x2)),
-    (0x0F944, (0x925, 0x1)),
-    (0x2F92B, (0xC87, 0x1)),
-    (0x001FF, (0x1AE, 0x2)),
-    (0x00386, (0x217, 0x2)),
-    (0x2F95F, (0xCBB, 0x1)),
-    (0x0FA32, (0xA07, 0x1)),
-    (0x0FA17, (0x9F3, 0x1)),
-    (0x01E17, (0x385, 0x3)),
-    (0x01F31, (0x612, 0x2)),
-    (0x2F980, (0xCDC, 0x1)),
-    (0x0FA2D, (0xA02, 0x1)),
-    (0x2F88E, (0xBEA, 0x1)),
-    (0x01FAC, (0x769, 0x4)),
-    (0x0FA3C, (0xA11, 0x1)),
-    (0x01F09, (0x5B0, 0x2)),
-    (0x01FDB, (0x7C9, 0x2)),
-    (0x2F9CA, (0xD26, 0x1)),
-    (0x01F2F, (0x60D, 0x3)),
-    (0x00623, (0x2B0, 0x2)),
-    (0x2F9F9, (0xD55, 0x1)),
-    (0x0FAB4, (0xA87, 0x1)),
-    (0x01EBF, (0x4FB, 0x3)),
-    (0x0F985, (0x966, 0x1)),
-    (0x01F6E, (0x6A3, 0x3)),
-    (0x2F965, (0xCC1, 0x1)),
-    (0x2F829, (0xB85, 0x1)),
-    (0x01E24, (0x3A2, 0x2)),
-    (0x2F8A2, (0xBFE, 0x1)),
-    (0x2F8CC, (0xC28, 0x1)),
-    (0x02ADC, (0x86B, 0x2)),
-    (0x004F3, (0x2A4, 0x2)),
-    (0x01F9D, (0x731, 0x4)),
-    (0x01F24, (0x5EE, 0x3)),
-    (0x2F9AF, (0xD0B, 0x1)),
-    (0x0FA77, (0xA4A, 0x1)),
-    (0x0FA93, (0xA66, 0x1)),
-    (0x01E61, (0x42A, 0x2)),
-    (0x00121, (0x0A8, 0x2)),
-    (0x01FCC, (0x7AC, 0x2)),
-    (0x2F9B6, (0xD12, 0x1)),
-    (0x2F963, (0xCBF, 0x1)),
-    (0x01EDB, (0x547, 0x3)),
-    (0x01FAB, (0x765, 0x4)),
-    (0x01E5A, (0x41A, 0x2)),
-    (0x2F80E, (0xB6A, 0x1)),
-    (0x0FA0A, (0x9EB, 0x1)),
-    (0x2F994, (0xCF0, 0x1)),
-    (0x2F91B, (0xC77, 0x1)),
-    (0x01EEE, (0x57C, 0x3)),
-    (0x01F67, (0x690, 0x3)),
-    (0x0F9B9, (0x99A, 0x1)),
-    (0x0FA63, (0xA38, 0x1)),
-    (0x2F972, (0xCCE, 0x1)),
-    (0x03079, (0x897, 0x2)),
-    (0x0F9EA, (0x9CB, 0x1)),
-    (0x0FB38, (0xACD, 0x2)),
-    (0x0FA9E, (0xA71, 0x1)),
-    (0x01E02, (0x356, 0x2)),
-    (0x01ECE, (0x522, 0x2)),
-    (0x01E75, (0x458, 0x2)),
-    (0x0FA46, (0xA1B, 0x1)),
-    (0x0FB43, (0xADD, 0x2)),
-    (0x2F80A, (0xB66, 0x1)),
-    (0x00115, (0x090, 0x2)),
-    (0x2F959, (0xCB5, 0x1)),
-    (0x030D1, (0x8C3, 0x2)),
-    (0x2F9B2, (0xD0E, 0x1)),
-    (0x2F98D, (0xCE9, 0x1)),
-    (0x0FA7E, (0xA51, 0x1)),
-    (0x00177, (0x132, 0x2)),
-    (0x2F867, (0xBC3, 0x1)),
-    (0x0FAA8, (0xA7B, 0x1)),
-    (0x0F97D, (0x95E, 0x1)),
-    (0x0F9B8, (0x999, 0x1)),
-    (0x0F968, (0x949, 0x1)),
-    (0x00D4B, (0x30B, 0x2)),
-    (0x0FA5A, (0xA2F, 0x1)),
-    (0x00104, (0x072, 0x2)),
-    (0x01F4C, (0x656, 0x3)),
-    (0x01F8E, (0x6F9, 0x4)),
-    (0x105C9, (0xAF3, 0x2)),
-    (0x01F2D, (0x607, 0x3)),
-    (0x0FA2B, (0xA00, 0x1)),
-    (0x2F8C5, (0xC21, 0x1)),
-    (0x01F73, (0x6AF, 0x2)),
-    (0x0FA73, (0xA46, 0x1)),
-    (0x0014E, (0x0E8, 0x2)),
-    (0x0F998, (0x979, 0x1)),
-    (0x0F94D, (0x92E, 0x1)),
-    (0x2F966, (0xCC2, 0x1)),
-    (0x2F91E, (0xC7A, 0x1)),
-    (0x00439, (0x256, 0x2)),
-    (0x01E98, (0x4A2, 0x2)),
-    (0x0FA8A, (0xA5D, 0x1)),
-    (0x000E9, (0x044, 0x2)),
-    (0x01FE9, (0x7E6, 0x2)),
-    (0x00170, (0x124, 0x2)),
-    (0x1109A, (0xAF7, 0x2)),
-    (0x11383, (0xB05, 0x2)),
-    (0x02270, (0x839, 0x2)),
-    (0x2F982, (0xCDE, 0x1)),
-    (0x0F9AF, (0x990, 0x1)),
-    (0x0FAB3, (0xA86, 0x1)),
-    (0x0F9E2, (0x9C3, 0x1)),
-    (0x2F9CB, (0xD27, 0x1)),
-    (0x0F947, (0x928, 0x1)),
-    (0x00F78, (0x32A, 0x2)),
-    (0x0021F, (0x1EA, 0x2)),
-    (0x2F928, (0xC84, 0x1)),
-    (0x004D2, (0x272, 0x2)),
-    (0x2F845, (0xBA1, 0x1)),
-    (0x01F23, (0x5EB, 0x3)),
-    (0x02285, (0x84B, 0x2)),
-    (0x0F903, (0x8E4, 0x1)),
-    (0x2F84A, (0xBA6, 0x1)),
-    (0x01F3F, (0x639, 0x3)),
-    (0x01E07, (0x360, 0x2)),
-    (0x2F823, (0xB7F, 0x1)),
-    (0x2F8D1, (0xC2D, 0x1)),
-    (0x01E11, (0x376, 0x2)),
-    (0x01FD2, (0x7B8, 0x3)),
-    (0x0017C, (0x13C, 0x2)),
-    (0x000E4, (0x03C, 0x2)),
-    (0x0F962, (0x943, 0x1)),
-    (0x001F4, (0x19A, 0x2)),
-    (0x0017A, (0x138, 0x2)),
-    (0x0F948, (0x929, 0x1)),
-    (0x001FE, (0x1AC, 0x2)),
-    (0x2F90F, (0xC6B, 0x1)),
-    (0x2F838, (0xB94, 0x1)),
-    (0x2F800, (0xB5C, 0x1)),
-    (0x0212B, (0x80F, 0x2)),
-    (0x2F83E, (0xB9A, 0x1)),
-    (0x0FA90, (0xA63, 0x1)),
-    (0x0095D, (0x2CE, 0x2)),
-    (0x2F96C, (0xCC8, 0x1)),
-    (0x0FA4D, (0xA22, 0x1)),
-    (0x0F906, (0x8E7, 0x1)),
-    (0x01F37, (0x623, 0x3)),
-    (0x0F9AC, (0x98D, 0x1)),
-    (0x01FE1, (0x7D3, 0x2)),
-    (0x01EC5, (0x50D, 0x3)),
-    (0x01ECB, (0x51C, 0x2)),
-    (0x2F947, (0xCA3, 0x1)),
-    (0x01F6D, (0x6A0, 0x3)),
-    (0x01E4C, (0x3F6, 0x3)),
-    (0x01FE6, (0x7DF, 0x2)),
-    (0x2F93C, (0xC98, 0x1)),
-    (0x2F9C4, (0xD20, 0x1)),
-    (0x001ED, (0x191, 0x3)),
-    (0x030F9, (0x8DB, 0x2)),
-    (0x2F898, (0xBF4, 0x1)),
-    (0x0FA0C, (0x9ED, 0x1)),
-    (0x000E0, (0x034, 0x2)),
-    (0x2F986, (0xCE2, 0x1)),
-    (0x01F61, (0x67F, 0x2)),
-    (0x01F7C, (0x6C1, 0x2)),
-    (0x01FA1, (0x740, 0x3)),
-    (0x0307C, (0x89B, 0x2)),
-    (0x01FEE, (0x7F0, 0x2)),
-    (0x2F8E6, (0xC42, 0x1)),
-    (0x00451, (0x25A, 0x2)),
-    (0x01E16, (0x382, 0x3)),
-    (0x00179, (0x136, 0x2)),
-    (0x00114, (0x08E, 0x2)),
-    (0x01F32, (0x614, 0x3)),
-    (0x0FB3E, (0xAD7, 0x2)),
-    (0x0F949, (0x92A, 0x1)),
-    (0x2F937, (0xC93, 0x1)),
-    (0x0F932, (0x913, 0x1)),
-    (0x0219B, (0x813, 0x2)),
-    (0x01E4F, (0x3FF, 0x3)),
-    (0x01E51, (0x405, 0x3)),
-    (0x01E8F, (0x490, 0x2)),
-    (0x030D4, (0x8C7, 0x2)),
-    (0x2FA0D, (0xD69, 0x1)),
-    (0x01EE1, (0x559, 0x3)),
-    (0x01026, (0x33A, 0x2)),
-    (0x0F9C2, (0x9A3, 0x1)),
-    (0x0012D, (0x0BC, 0x2)),
-    (0x2F864, (0xBC0, 0x1)),
-    (0x2F88D, (0xBE9, 0x1)),
-    (0x2F9CC, (0xD28, 0x1)),
-    (0x16124, (0xB25, 0x2)),
-    (0x0FA98, (0xA6B, 0x1)),
-    (0x2F901, (0xC5D, 0x1)),
-    (0x2F9D3, (0xD2F, 0x1)),
-    (0x01E96, (0x49E, 0x2)),
-    (0x0FA60, (0xA35, 0x1)),
-    (0x0FA62, (0xA37, 0x1)),
-    (0x000FD, (0x066, 0x2)),
-    (0x2FA00, (0xD5C, 0x1)),
-    (0x01F06, (0x5A8, 0x3)),
-    (0x00128, (0x0B2, 0x2)),
-    (0x01F0B, (0x5B5, 0x3)),
-    (0x2F99A, (0xCF6, 0x1)),
-    (0x2F970, (0xCCC, 0x1)),
-    (0x2FA13, (0xD6F, 0x1)),
-    (0x01F0F, (0x5C1, 0x3)),
-    (0x000F1, (0x052, 0x2)),
-    (0x2F8D3, (0xC2F, 0x1)),
-    (0x0F919, (0x8FA, 0x1)),
-    (0x02329, (0x869, 0x1)),
-    (0x0FB32, (0xAC3, 0x2)),
-    (0x0FA48, (0xA1D, 0x1)),
-    (0x0F953, (0x934, 0x1)),
-    (0x2F873, (0xBCF, 0x1)),
-    (0x0012E, (0x0BE, 0x2)),
-    (0x0F963, (0x944, 0x1)),
-    (0x01F53, (0x663, 0x3)),
-    (0x0F94E, (0x92F, 0x1)),
-    (0x0095A, (0x2C8, 0x2)),
-    (0x2F929, (0xC85, 0x1)),
-    (0x0012C, (0x0BA, 0x2)),
-    (0x00119, (0x098, 0x2)),
-    (0x2F997, (0xCF3, 0x1)),
-    (0x0FACD, (0xAA0, 0x1)),
-    (0x01E1B, (0x38E, 0x2)),
-    (0x01ED6, (0x538, 0x3)),
-    (0x0F945, (0x926, 0x1)),
-    (0x01FA8, (0x75B, 0x3)),
-    (0x0FA3A, (0xA0F, 0x1)),
-    (0x2F94C, (0xCA8, 0x1)),
-    (0x0F9C6, (0x9A7, 0x1)),
-    (0x0FB4E, (0xAF1, 0x2)),
-    (0x01F20, (0x5E4, 0x2)),
-    (0x0FAD3, (0xAA6, 0x1)),
-    (0x02278, (0x841, 0x2)),
-    (0x01E86, (0x47E, 0x2)),
-    (0x0F92D, (0x90E, 0x1)),
-    (0x0FA5B, (0xA30, 0x1)),
-    (0x0FA49, (0xA1E, 0x1)),
-    (0x0FAC7, (0xA9A, 0x1)),
-    (0x0F91D, (0x8FE, 0x1)),
-    (0x2F852, (0xBAE, 0x1)),
-    (0x01E3C, (0x3D6, 0x2)),
-    (0x01E25, (0x3A4, 0x2)),
-    (0x0F938, (0x919, 0x1)),
-    (0x2F919, (0xC75, 0x1)),
-    (0x00205, (0x1BA, 0x2)),
-    (0x2F843, (0xB9F, 0x1)),
-    (0x0FB33, (0xAC5, 0x2)),
-    (0x01FB8, (0x78A, 0x2)),
-    (0x0F9D7, (0x9B8, 0x1)),
-    (0x0FB4A, (0xAE9, 0x2)),
-    (0x00147, (0x0E0, 0x2)),
-    (0x0FAAA, (0xA7D, 0x1)),
-    (0x2F858, (0xBB4, 0x1)),
-    (0x01E8A, (0x486, 0x2)),
-    (0x001E1, (0x17B, 0x3)),
-    (0x2F950, (0xCAC, 0x1)),
-    (0x2FA19, (0xD75, 0x1)),
-    (0x0FA6C, (0xA41, 0x1)),
-    (0x01F93, (0x70B, 0x4)),
-    (0x0FA74, (0xA47, 0x1)),
-    (0x00109, (0x07C, 0x2)),
-    (0x01F59, (0x672, 0x2)),
-    (0x0F9D5, (0x9B6, 0x1)),
-    (0x0FA70, (0xA43, 0x1)),
-    (0x0FAA9, (0xA7C, 0x1)),
-    (0x2F9F4, (0xD50, 0x1)),
-    (0x2F948, (0xCA4, 0x1)),
-    (0x0F9DB, (0x9BC, 0x1)),
-    (0x01E2B, (0x3B0, 0x2)),
-    (0x2F9F3, (0xD4F, 0x1)),
-    (0x0016F, (0x122, 0x2)),
-    (0x01F97, (0x71B, 0x4)),
-    (0x01FA2, (0x743, 0x4)),
-    (0x2F956, (0xCB2, 0x1)),
-    (0x00F81, (0x32C, 0x2)),
-    (0x01EDF, (0x553, 0x3)),
-    (0x01E41, (0x3E0, 0x2)),
-    (0x1D15F, (0xB3B, 0x2)),
-    (0x01E66, (0x436, 0x3)),
-    (0x2F8E7, (0xC43, 0x1)),
-    (0x0FABD, (0xA90, 0x1)),
-    (0x0F92A, (0x90B, 0x1)),
-    (0x0FABA, (0xA8D, 0x1)),
-    (0x01ED5, (0x535, 0x3)),
-    (0x01F29, (0x5FC, 0x2)),
-    (0x01EB0, (0x4D4, 0x3)),
-    (0x01FF6, (0x7FB, 0x2)),
-    (0x0FA69, (0xA3E, 0x1)),
-    (0x00231, (0x207, 0x3)),
-    (0x0011A, (0x09A, 0x2)),
-    (0x2F916, (0xC72, 0x1)),
-    (0x000D2, (0x020, 0x2)),
-    (0x01E26, (0x3A6, 0x2)),
-    (0x2F9E8, (0xD44, 0x1)),
-    (0x00233, (0x20C, 0x2)),
-    (0x0F936, (0x917, 0x1)),
-    (0x01FEC, (0x7EC, 0x2)),
-    (0x00202, (0x1B4, 0x2)),
-    (0x0F9AD, (0x98E, 0x1)),
-    (0x2F927, (0xC83, 0x1)),
-    (0x2F856, (0xBB2, 0x1)),
-    (0x00931, (0x2C0, 0x2)),
-    (0x01E70, (0x44E, 0x2)),
-    (0x00135, (0x0C6, 0x2)),
-    (0x01E33, (0x3C2, 0x2)),
-    (0x01F82, (0x6CB, 0x4)),
-    (0x01F27, (0x5F7, 0x3)),
-    (0x2F809, (0xB65, 0x1)),
-    (0x0F920, (0x901, 0x1)),
-    (0x2F936, (0xC92, 0x1)),
-    (0x00340, (0x20E, 0x1)),
-    (0x003AB, (0x22B, 0x2)),
-    (0x2F86C, (0xBC8, 0x1)),
-    (0x01ED3, (0x52F, 0x3)),
-    (0x00103, (0x070, 0x2)),
-    (0x0F9A8, (0x989, 0x1)),
-    (0x0011C, (0x09E, 0x2)),
-    (0x0F92C, (0x90D, 0x1)),
-    (0x000C9, (0x010, 0x2)),
-    (0x0F9B4, (0x995, 0x1)),
-    (0x2F939, (0xC95, 0x1)),
-    (0x0F913, (0x8F4, 0x1)),
-    (0x0FA52, (0xA27, 0x1)),
-    (0x00210, (0x1D0, 0x2)),
-    (0x000F3, (0x056, 0x2)),
-    (0x2F804, (0xB60, 0x1)),
-    (0x2F87D, (0xBD9, 0x1)),
-    (0x0FAC9, (0xA9C, 0x1)),
-    (0x01E1C, (0x390, 0x3)),
-    (0x0011E, (0x0A2, 0x2)),
-    (0x0016C, (0x11C, 0x2)),
-    (0x00A59, (0x2E2, 0x2)),
-    (0x0FA26, (0x9FE, 0x1)),
-    (0x0FA45, (0xA1A, 0x1)),
-    (0x00112, (0x08A, 0x2)),
-    (0x2F82E, (0xB8A, 0x1)),
-    (0x0FA33, (0xA08, 0x1)),
-    (0x1112F, (0xAFF, 0x2)),
-    (0x00206, (0x1BC, 0x2)),
-    (0x030DC, (0x8D1, 0x2)),
-    (0x003CB, (0x23A, 0x2)),
-    (0x0F986, (0x967, 0x1)),
-    (0x0FB2D, (0xAB8, 0x3)),
-    (0x01FA9, (0x75E, 0x3)),
-    (0x0304E, (0x86F, 0x2)),
-    (0x0F9E6, (0x9C7, 0x1)),
-    (0x115BB, (0xB1B, 0x2)),
-    (0x11391, (0xB0B, 0x2)),
-    (0x01B3D, (0x34A, 0x2)),
-    (0x00DDA, (0x30F, 0x2)),
-    (0x0F992, (0x973, 0x1)),
-    (0x0015D, (0x102, 0x2)),
-    (0x00477, (0x268, 0x2)),
-    (0x0F9B1, (0x992, 0x1)),
-    (0x0040D, (0x250, 0x2)),
-    (0x030F7, (0x8D7, 0x2)),
-    (0x0F977, (0x958, 0x1)),
-    (0x0FAC4, (0xA97, 0x1)),
-    (0x0FA3B, (0xA10, 0x1)),
-    (0x2F88B, (0xBE7, 0x1)),
-    (0x02279, (0x843, 0x2)),
-    (0x0FA01, (0x9E2, 0x1)),
-    (0x01F79, (0x6BB, 0x2)),
-    (0x03062, (0x883, 0x2)),
-    (0x2F9D6, (0xD32, 0x1)),
-    (0x004ED, (0x298, 0x2)),
-    (0x2FA05, (0xD61, 0x1)),
-    (0x110AB, (0xAFB, 0x2)),
-    (0x0F9F1, (0x9D2, 0x1)),
-    (0x01E54, (0x40E, 0x2)),
-    (0x2F8B6, (0xC12, 0x1)),
-    (0x0FA25, (0x9FD, 0x1)),
-    (0x001D3, (0x156, 0x2)),
-    (0x01E2D, (0x3B4, 0x2)),
-    (0x00622, (0x2AE, 0x2)),
-    (0x0F9A9, (0x98A, 0x1)),
-    (0x00CC7, (0x300, 0x2)),
-    (0x01F7A, (0x6BD, 0x2)),
-    (0x0FA57, (0xA2C, 0x1)),
-    (0x2F9A8, (0xD04, 0x1)),
-    (0x001E0, (0x178, 0x3)),
-    (0x2F904, (0xC60, 0x1)),
-    (0x01FA7, (0x757, 0x4)),
-    (0x01EC3, (0x507, 0x3)),
-    (0x2F983, (0xCDF, 0x1)),
-    (0x009CC, (0x2D6, 0x2)),
-    (0x000D4, (0x024, 0x2)),
-    (0x0FAD9, (0xAAC, 0x1)),
-    (0x01F04, (0x5A2, 0x3)),
-    (0x2F8B0, (0xC0C, 0x1)),
-    (0x2F8D7, (0xC33, 0x1)),
-    (0x0F9FB, (0x9DC, 0x1)),
-    (0x2F9FB, (0xD57, 0x1)),
-    (0x00217, (0x1DE, 0x2)),
-    (0x2F9C1, (0xD1D, 0x1)),
-    (0x2F98B, (0xCE7, 0x1)),
-    (0x01F56, (0x66C, 0x3)),
-    (0x2F9E2, (0xD3E, 0x1)),
-    (0x00625, (0x2B4, 0x2)),
-    (0x0307A, (0x899, 0x2)),
-    (0x2F818, (0xB74, 0x1)),
-    (0x01E83, (0x478, 0x2)),
-    (0x01FB7, (0x787, 0x3)),
-    (0x01ECA, (0x51A, 0x2)),
-    (0x2F8F2, (0xC4E, 0x1)),
-    (0x2F990, (0xCEC, 0x1)),
-    (0x2F9DF, (0xD3B, 0x1)),
-    (0x2F859, (0xBB5, 0x1)),
-    (0x2FA09, (0xD65, 0x1)),
-    (0x2F883, (0xBDF, 0x1)),
-    (0x01FD7, (0x7C0, 0x3)),
-    (0x2F872, (0xBCE, 0x1)),
-    (0x2F85E, (0xBBA, 0x1)),
-    (0x2F9B5, (0xD11, 0x1)),
-    (0x0F9F4, (0x9D5, 0x1)),
-    (0x00213, (0x1D6, 0x2)),
-    (0x01EF4, (0x58C, 0x2)),
-    (0x2F9DA, (0xD36, 0x1)),
-    (0x01E36, (0x3C8, 0x2)),
-    (0x006D3, (0x2BC, 0x2)),
-    (0x2F9FF, (0xD5B, 0x1)),
-    (0x2F97C, (0xCD8, 0x1)),
-    (0x01FFC, (0x808, 0x2)),
-    (0x2F8AD, (0xC09, 0x1)),
-    (0x2F8FC, (0xC58, 0x1)),
-    (0x01E31, (0x3BE, 0x2)),
-    (0x003AC, (0x22D, 0x2)),
-    (0x01E80, (0x472, 0x2)),
-    (0x001D2, (0x154, 0x2)),
-    (0x0F901, (0x8E2, 0x1)),
-    (0x0F9DF, (0x9C0, 0x1)),
-    (0x0FA83, (0xA56, 0x1)),
-    (0x2F946, (0xCA2, 0x1)),
-    (0x2F863, (0xBBF, 0x1)),
-    (0x01F8B, (0x6ED, 0x4)),
-    (0x0FA7C, (0xA4F, 0x1)),
-    (0x00151, (0x0EE, 0x2)),
-    (0x01FC1, (0x795, 0x2)),
-    (0x2F8F8, (0xC54, 0x1)),
-    (0x2F9B3, (0xD0F, 0x1)),
-    (0x2F8A6, (0xC02, 0x1)),
-    (0x003AE, (0x231, 0x2)),
-    (0x2F9C9, (0xD25, 0x1)),
-    (0x2F9D8, (0xD34, 0x1)),
-    (0x2F81C, (0xB78, 0x1)),
-    (0x01EBA, (0x4F0, 0x2)),
-    (0x2F853, (0xBAF, 0x1)),
-    (0x00118, (0x096, 0x2)),
-    (0x2F8B7, (0xC13, 0x1)),
-    (0x2F9B8, (0xD14, 0x1)),
-    (0x2F93F, (0xC9B, 0x1)),
-    (0x0F9E0, (0x9C1, 0x1)),
-    (0x00385, (0x215, 0x2)),
-    (0x2F888, (0xBE4, 0x1)),
-    (0x0F99D, (0x97E, 0x1)),
-    (0x01E5B, (0x41C, 0x2)),
-    (0x000C4, (0x008, 0x2)),
-    (0x16122, (0xB21, 0x2)),
-    (0x03058, (0x879, 0x2)),
-    (0x01E68, (0x43C, 0x3)),
-    (0x0212A, (0x80E, 0x1)),
-    (0x2F921, (0xC7D, 0x1)),
-    (0x02260, (0x82F, 0x2)),
-    (0x0FB1F, (0xAAF, 0x2)),
-    (0x02001, (0x80C, 0x1)),
-    (0x01F88, (0x6E3, 0x3)),
-    (0x01F9C, (0x72D, 0x4)),
-    (0x00137, (0x0CA, 0x2)),
-    (0x0FA30, (0xA05, 0x1)),
-    (0x01E49, (0x3F0, 0x2)),
-    (0x0F9E1, (0x9C2, 0x1)),
-    (0x0FA8F, (0xA62, 0x1)),
-    (0x11938, (0xB1D, 0x2)),
-    (0x0F9D1, (0x9B2, 0x1)),
-    (0x0020B, (0x1C6, 0x2)),
-    (0x0FA9C, (0xA6F, 0x1)),
-    (0x0F982, (0x963, 0x1)),
-    (0x2F97B, (0xCD7, 0x1)),
-    (0x00400, (0x246, 0x2)),
-    (0x0FA40, (0xA15, 0x1)),
-    (0x0F96D, (0x94E, 0x1)),
-    (0x02241, (0x827, 0x2)),
-    (0x2F924, (0xC80, 0x1)),
-    (0x00172, (0x128, 0x2)),
-    (0x01E1F, (0x398, 0x2)),
-    (0x2F993, (0xCEF, 0x1)),
-    (0x001FB, (0x1A5, 0x3)),
-    (0x00F75, (0x326, 0x2)),
-    (0x00162, (0x10C, 0x2)),
-    (0x001E2, (0x17E, 0x2)),
-    (0x00374, (0x213, 0x1)),
-    (0x0F997, (0x978, 0x1)),
-    (0x004DE, (0x282, 0x2)),
-    (0x000D9, (0x02A, 0x2)),
-    (0x2F9EA, (0xD46, 0x1)),
-    (0x2F8AB, (0xC07, 0x1)),
-    (0x0FA7A, (0xA4D, 0x1)),
-    (0x2F8FA, (0xC56, 0x1)),
-    (0x0F90E, (0x8EF, 0x1)),
-    (0x0F983, (0x964, 0x1)),
-    (0x0016A, (0x118, 0x2)),
-    (0x0FA68, (0xA3D, 0x1)),
-    (0x000FB, (0x062, 0x2)),
-    (0x2FA16, (0xD72, 0x1)),
-    (0x01FFA, (0x804, 0x2)),
-    (0x01F02, (0x59C, 0x3)),
-    (0x2FA02, (0xD5E, 0x1)),
-    (0x01E3A, (0x3D2, 0x2)),
-    (0x01E69, (0x43F, 0x3)),
-    (0x0FAAD, (0xA80, 0x1)),
-    (0x004F8, (0x2AA, 0x2)),
-    (0x004D3, (0x274, 0x2)),
-    (0x01EF1, (0x585, 0x3)),
-    (0x1138E, (0xB09, 0x2)),
-    (0x2F8A5, (0xC01, 0x1)),
-    (0x2F837, (0xB93, 0x1)),
-    (0x01E0A, (0x368, 0x2)),
-    (0x0FA96, (0xA69, 0x1)),
-    (0x0014D, (0x0E6, 0x2)),
-    (0x1D162, (0xB43, 0x3)),
-    (0x0F923, (0x904, 0x1)),
-    (0x0FAB7, (0xA8A, 0x1)),
-    (0x01F11, (0x5C6, 0x2)),
-    (0x000EE, (0x04E, 0x2)),
-    (0x030C2, (0x8B9, 0x2)),
-    (0x0FA31, (0xA06, 0x1)),
-    (0x001D6, (0x15D, 0x3)),
-    (0x0FB4D, (0xAEF, 0x2)),
-    (0x000EC, (0x04A, 0x2)),
-    (0x2F969, (0xCC5, 0x1)),
-    (0x0F921, (0x902, 0x1)),
-    (0x00F76, (0x328, 0x2)),
-    (0x01EB5, (0x4E3, 0x3)),
-    (0x00155, (0x0F2, 0x2)),
-    (0x0FA61, (0xA36, 0x1)),
-    (0x0020E, (0x1CC, 0x2)),
-    (0x01F54, (0x666, 0x3)),
-    (0x2F8D9, (0xC35, 0x1)),
-    (0x0FAA1, (0xA74, 0x1)),
-    (0x2F985, (0xCE1, 0x1)),
-    (0x0F96F, (0x950, 0x1)),
-    (0x2F974, (0xCD0, 0x1)),
-    (0x01EC4, (0x50A, 0x3)),
-    (0x01E44, (0x3E6, 0x2)),
-    (0x2F8F0, (0xC4C, 0x1)),
-    (0x0FA81, (0xA54, 0x1)),
-    (0x0F9DE, (0x9BF, 0x1)),
-    (0x2F9A5, (0xD01, 0x1)),
-    (0x01FEA, (0x7E8, 0x2)),
-    (0x0FABF, (0xA92, 0x1)),
-    (0x00457, (0x25E, 0x2)),
-    (0x01E21, (0x39C, 0x2)),
-    (0x0FAB0, (0xA83, 0x1)),
-    (0x01E55, (0x410, 0x2)),
-    (0x01EF8, (0x594, 0x2)),
-    (0x0F91B, (0x8FC, 0x1)),
-    (0x01E50, (0x402, 0x3)),
-    (0x000EB, (0x048, 0x2)),
-    (0x2FA0A, (0xD66, 0x1)),
-    (0x0F94F, (0x930, 0x1)),
-    (0x004E4, (0x28A, 0x2)),
-    (0x0013B, (0x0D0, 0x2)),
-    (0x00169, (0x116, 0x2)),
-    (0x2FA01, (0xD5D, 0x1)),
-    (0x0F9E5, (0x9C6, 0x1)),
-    (0x0FA1A, (0x9F6, 0x1)),
-    (0x2F8AC, (0xC08, 0x1)),
-    (0x01F6A, (0x697, 0x3)),
-    (0x00CC8, (0x302, 0x2)),
-    (0x0F911, (0x8F2, 0x1)),
-    (0x0F928, (0x909, 0x1)),
-    (0x01E6C, (0x446, 0x2)),
-    (0x02226, (0x825, 0x2)),
-    (0x2F8E9, (0xC45, 0x1)),
-    (0x0F9FA, (0x9DB, 0x1)),
-    (0x01EE9, (0x56D, 0x3)),
-    (0x01F80, (0x6C5, 0x3)),
-    (0x01F13, (0x5CB, 0x3)),
-    (0x2F98C, (0xCE8, 0x1)),
-    (0x2F96B, (0xCC7, 0x1)),
-    (0x01FFB, (0x806, 0x2)),
-    (0x2F920, (0xC7C, 0x1)),
-    (0x0F951, (0x932, 0x1)),
-    (0x1112E, (0xAFD, 0x2)),
-    (0x000DC, (0x030, 0x2)),
-    (0x2FA1C, (0xD78, 0x1)),
-    (0x2F940, (0xC9C, 0x1)),
-    (0x2F84E, (0xBAA, 0x1)),
-    (0x0FA03, (0x9E4, 0x1)),
-    (0x0F914, (0x8F5, 0x1)),
-    (0x0F931, (0x912, 0x1)),
-    (0x0F98A, (0x96B, 0x1)),
-    (0x00F69, (0x322, 0x2)),
-    (0x0F9BD, (0x99E, 0x1)),
-    (0x030B2, (0x8A9, 0x2)),
-    (0x01FBE, (0x794, 0x1)),
-    (0x2F8C2, (0xC1E, 0x1)),
-    (0x0FAD8, (0xAAB, 0x1)),
-    (0x01FDE, (0x7CD, 0x2)),
-    (0x01F8F, (0x6FD, 0x4)),
-    (0x2FA11, (0xD6D, 0x1)),
-    (0x01E5E, (0x424, 0x2)),
-    (0x2F9C6, (0xD22, 0x1)),
-    (0x0014F, (0x0EA, 0x2)),
-    (0x030D6, (0x8C9, 0x2)),
-    (0x2F968, (0xCC4, 0x1)),
-    (0x0F952, (0x933, 0x1)),
-    (0x2F8E8, (0xC44, 0x1)),
-    (0x01F50, (0x65C, 0x2)),
-    (0x01E56, (0x412, 0x2)),
-    (0x0F9CC, (0x9AD, 0x1)),
-    (0x001D4, (0x158, 0x2)),
-    (0x0FABE, (0xA91, 0x1)),
-    (0x00123, (0x0AC, 0x2)),
-    (0x0FB3C, (0xAD5, 0x2)),
-    (0x0F996, (0x977, 0x1)),
-    (0x01E8D, (0x48C, 0x2)),
-    (0x2F8DB, (0xC37, 0x1)),
-    (0x00215, (0x1DA, 0x2)),
-    (0x0F909, (0x8EA, 0x1)),
-    (0x16123, (0xB23, 0x2)),
-    (0x0FA6B, (0xA40, 0x1)),
-    (0x02247, (0x82B, 0x2)),
-    (0x030D0, (0x8C1, 0x2)),
-    (0x1D1BE, (0xB53, 0x3)),
-    (0x004D1, (0x270, 0x2)),
-    (0x0FA79, (0xA4C, 0x1)),
-    (0x01E7F, (0x470, 0x2)),
-    (0x0FA12, (0x9F0, 0x1)),
-    (0x022AC, (0x851, 0x2)),
-    (0x0F9D4, (0x9B5, 0x1)),
-    (0x01EDA, (0x544, 0x3)),
-    (0x0F90D, (0x8EE, 0x1)),
-    (0x0F922, (0x903, 0x1)),
-    (0x01F8C, (0x6F1, 0x4)),
-    (0x01E13, (0x37A, 0x2)),
-    (0x030F4, (0x8D5, 0x2)),
-    (0x0FA88, (0xA5B, 0x1)),
-    (0x000CA, (0x012, 0x2)),
-    (0x01E0C, (0x36C, 0x2)),
-    (0x114BE, (0xB17, 0x2)),
-    (0x2F964, (0xCC0, 0x1)),
-    (0x030D9, (0x8CD, 0x2)),
-    (0x2F907, (0xC63, 0x1)),
-    (0x00161, (0x10A, 0x2)),
-    (0x0FAD0, (0xAA3, 0x1)),
-    (0x2FA03, (0xD5F, 0x1)),
-    (0x01FD6, (0x7BE, 0x2)),
-    (0x2F8B4, (0xC10, 0x1)),
-    (0x2F893, (0xBEF, 0x1)),
-    (0x01E45, (0x3E8, 0x2)),
-    (0x16127, (0xB2C, 0x3)),
-    (0x000ED, (0x04C, 0x2)),
-    (0x0FA35, (0xA0A, 0x1)),
-    (0x001FC, (0x1A8, 0x2)),
-    (0x01E60, (0x428, 0x2)),
-    (0x01E7D, (0x46C, 0x2)),
-    (0x0FA4C, (0xA21, 0x1)),
-    (0x00200, (0x1B0, 0x2)),
-    (0x0F93F, (0x920, 0x1)),
-    (0x2F911, (0xC6D, 0x1)),
-    (0x00168, (0x114, 0x2)),
-    (0x0F993, (0x974, 0x1)),
-    (0x00136, (0x0C8, 0x2)),
-    (0x01EAA, (0x4C2, 0x3)),
-    (0x0F969, (0x94A, 0x1)),
-    (0x2F8D5, (0xC31, 0x1)),
-    (0x01E99, (0x4A4, 0x2)),
-    (0x01E6F, (0x44C, 0x2)),
-    (0x0FA1B, (0x9F7, 0x1)),
-    (0x01E9B, (0x4A6, 0x2)),
-    (0x2F808, (0xB64, 0x1)),
-    (0x01F43, (0x643, 0x3)),
-    (0x0F980, (0x961, 0x1)),
-    (0x0FA58, (0xA2D, 0x1)),
-    (0x2F8A8, (0xC04, 0x1)),
-    (0x03052, (0x873, 0x2)),
-    (0x2F9E9, (0xD45, 0x1)),
-    (0x00344, (0x211, 0x2)),
-    (0x0FA38, (0xA0D, 0x1)),
-    (0x2F935, (0xC91, 0x1)),
-    (0x01F14, (0x5CE, 0x3)),
-    (0x01F39, (0x628, 0x2)),
-    (0x01E71, (0x450, 0x2)),
-    (0x0F96B, (0x94C, 0x1)),
-    (0x0F9F3, (0x9D4, 0x1)),
-    (0x0FAB6, (0xA89, 0x1)),
-    (0x01FD8, (0x7C3, 0x2)),
-    (0x0F995, (0x976, 0x1)),
-    (0x01EF9, (0x596, 0x2)),
-    (0x2F82F, (0xB8B, 0x1)),
-    (0x2F9BF, (0xD1B, 0x1)),
-    (0x0FA2E, (0xA03, 0x1)),
-    (0x2F814, (0xB70, 0x1)),
-    (0x0FAD1, (0xAA4, 0x1)),
-    (0x01E1D, (0x393, 0x3)),
-    (0x0038F, (0x224, 0x2)),
-    (0x2F8A1, (0xBFD, 0x1)),
-    (0x00228, (0x1F0, 0x2)),
-    (0x2F81E, (0xB7A, 0x1)),
-    (0x2F811, (0xB6D, 0x1)),
-    (0x001CD, (0x14A, 0x2)),
-    (0x01FC7, (0x7A1, 0x3)),
-    (0x0022A, (0x1F4, 0x3)),
-    (0x01F6B, (0x69A, 0x3)),
-    (0x00624, (0x2B2, 0x2)),
-    (0x01FC8, (0x7A4, 0x2)),
-    (0x0FAC2, (0xA95, 0x1)),
-    (0x0F9E7, (0x9C8, 0x1)),
-    (0x2F8FE, (0xC5A, 0x1)),
-    (0x030C9, (0x8BF, 0x2)),
-    (0x2F908, (0xC64, 0x1)),
-    (0x2F9E7, (0xD43, 0x1)),
-    (0x0FABB, (0xA8E, 0x1)),
-    (0x2FA1B, (0xD77, 0x1)),
-    (0x00139, (0x0CC, 0x2)),
-    (0x0FA1D, (0x9F9, 0x1)),
-    (0x01EF2, (0x588, 0x2)),
-    (0x2F998, (0xCF4, 0x1)),
-    (0x2F91F, (0xC7B, 0x1)),
-    (0x0FA9B, (0xA6E, 0x1)),
-    (0x0FA80, (0xA53, 0x1)),
-    (0x2F95C, (0xCB8, 0x1)),
-    (0x2F9F5, (0xD51, 0x1)),
-    (0x2F91A, (0xC76, 0x1)),
-    (0x01F70, (0x6A9, 0x2)),
-    (0x2F86B, (0xBC7, 0x1)),
-    (0x2F85A, (0xBB6, 0x1)),
-    (0x0013E, (0x0D6, 0x2)),
-    (0x2F850, (0xBAC, 0x1)),
-    (0x004DB, (0x27C, 0x2)),
-    (0x2F871, (0xBCD, 0x1)),
-    (0x0F970, (0x951, 0x1)),
-    (0x004DD, (0x280, 0x2)),
-    (0x01E1A, (0x38C, 0x2)),
-    (0x2F90E, (0xC6A, 0x1)),
-    (0x01F65, (0x68A, 0x3)),
-    (0x0F929, (0x90A, 0x1)),
-    (0x01EDD, (0x54D, 0x3)),
-    (0x01F89, (0x6E6, 0x3)),
-    (0x004D7, (0x278, 0x2)),
-    (0x01E2F, (0x3B9, 0x3)),
-    (0x2F860, (0xBBC, 0x1)),
-    (0x01F55, (0x669, 0x3)),
-    (0x0FAA4, (0xA77, 0x1)),
-    (0x0FA59, (0xA2E, 0x1)),
-    (0x0FB4B, (0xAEB, 0x2)),
-    (0x2F8BF, (0xC1B, 0x1)),
-    (0x01EE7, (0x568, 0x2)),
-    (0x004F9, (0x2AC, 0x2)),
-    (0x2F995, (0xCF1, 0x1)),
-    (0x022AF, (0x857, 0x2)),
-    (0x0F9B6, (0x997, 0x1)),
-    (0x01EBC, (0x4F4, 0x2)),
-    (0x004F5, (0x2A8, 0x2)),
-    (0x2F826, (0xB82, 0x1)),
-    (0x00116, (0x092, 0x2)),
-    (0x00453, (0x25C, 0x2)),
-    (0x0FB47, (0xAE3, 0x2)),
-    (0x01E08, (0x362, 0x3)),
-    (0x2F8E1, (0xC3D, 0x1)),
-    (0x001DC, (0x16F, 0x3)),
-    (0x0FA05, (0x9E6, 0x1)),
-    (0x0F908, (0x8E9, 0x1)),
-    (0x2F839, (0xB95, 0x1)),
-    (0x0F95F, (0x940, 0x1)),
-    (0x0012A, (0x0B6, 0x2)),
-    (0x0040E, (0x252, 0x2)),
-    (0x000D3, (0x022, 0x2)),
-    (0x03069, (0x889, 0x2)),
-    (0x2F944, (0xCA0, 0x1)),
-    (0x0F90F, (0x8F0, 0x1)),
-    (0x0F9A1, (0x982, 0x1)),
-    (0x001D0, (0x150, 0x2)),
-    (0x01F9B, (0x729, 0x4)),
-    (0x2FA04, (0xD60, 0x1)),
-    (0x01F74, (0x6B1, 0x2)),
-    (0x01F1D, (0x5E1, 0x3)),
-    (0x0F9F8, (0x9D9, 0x1)),
-    (0x2F9E3, (0xD3F, 0x1)),
-    (0x01FE2, (0x7D5, 0x3)),
-    (0x02288, (0x84D, 0x2)),
-    (0x2F9C2, (0xD1E, 0x1)),
-    (0x030D3, (0x8C5, 0x2)),
-    (0x030C0, (0x8B7, 0x2)),
-    (0x0226F, (0x837, 0x2)),
-    (0x2F9C8, (0xD24, 0x1)),
-    (0x2F8ED, (0xC49, 0x1)),
-    (0x2F85C, (0xBB8, 0x1)),
-    (0x01F0C, (0x5B8, 0x3)),
-    (0x01FC3, (0x79A, 0x2)),
-    (0x01FF2, (0x7F3, 0x3)),
-    (0x2F8EC, (0xC48, 0x1)),
-    (0x2F885, (0xBE1, 0x1)),
-    (0x2FA1A, (0xD76, 0x1)),
-    (0x00216, (0x1DC, 0x2)),
-    (0x2F8C7, (0xC23, 0x1)),
-    (0x01F71, (0x6AB, 0x2)),
-    (0x00209, (0x1C2, 0x2)),
-    (0x0F999, (0x97A, 0x1)),
-    (0x01FD1, (0x7B6, 0x2)),
-    (0x03094, (0x89F, 0x2)),
-    (0x2F878, (0xBD4, 0x1)),
-    (0x01E5C, (0x41E, 0x3)),
-    (0x01FED, (0x7EE, 0x2)),
-    (0x0F9F7, (0x9D8, 0x1)),
-    (0x2F9DE, (0xD3A, 0x1)),
-    (0x0F925, (0x906, 0x1)),
-    (0x001DA, (0x169, 0x3)),
-    (0x000D5, (0x026, 0x2)),
-    (0x0FA08, (0x9E9, 0x1)),
-    (0x01EC9, (0x518, 0x2)),
-    (0x00117, (0x094, 0x2)),
-    (0x01F3A, (0x62A, 0x3)),
-    (0x2F9FE, (0xD5A, 0x1)),
-    (0x01F2C, (0x604, 0x3)),
-    (0x0F94C, (0x92D, 0x1)),
-    (0x01E52, (0x408, 0x3)),
-    (0x02249, (0x82D, 0x2)),
-    (0x0021E, (0x1E8, 0x2)),
-    (0x01F44, (0x646, 0x3)),
-    (0x0F988, (0x969, 0x1)),
-    (0x01E4B, (0x3F4, 0x2)),
-    (0x01FE0, (0x7D1, 0x2)),
-    (0x01F6C, (0x69D, 0x3)),
-    (0x0FA66, (0xA3B, 0x1)),
-    (0x2F82B, (0xB87, 0x1)),
-    (0x01E67, (0x439, 0x3)),
-    (0x2F976, (0xCD2, 0x1)),
-    (0x0FA43, (0xA18, 0x1)),
-    (0x01E35, (0x3C6, 0x2)),
-    (0x2F83D, (0xB99, 0x1)),
-    (0x2F8DE, (0xC3A, 0x1)),
-    (0x2F813, (0xB6F, 0x1)),
-    (0x00175, (0x12E, 0x2)),
-    (0x0F979, (0x95A, 0x1)),
-    (0x2F942, (0xC9E, 0x1)),
-    (0x0F9FE, (0x9DF, 0x1)),
-    (0x0FAA3, (0xA76, 0x1)),
-    (0x0F974, (0x955, 0x1)),
-    (0x0F9AA, (0x98B, 0x1)),
-    (0x0F9C1, (0x9A2, 0x1)),
-    (0x02000, (0x80B, 0x1)),
-    (0x2F905, (0xC61, 0x1)),
-    (0x1109C, (0xAF9, 0x2)),
-    (0x0FA7F, (0xA52, 0x1)),
-    (0x2F890, (0xBEC, 0x1)),
-    (0x03073, (0x88F, 0x2)),
-    (0x0F9E8, (0x9C9, 0x1)),
-    (0x2F887, (0xBE3, 0x1)),
-    (0x000FA, (0x060, 0x2)),
-    (0x2F803, (0xB5F, 0x1)),
-    (0x2F9CF, (0xD2B, 0x1)),
-    (0x2F8A7, (0xC03, 0x1)),
-    (0x2F820, (0xB7C, 0x1)),
-    (0x0FB30, (0xABF, 0x2)),
-    (0x000EF, (0x050, 0x2)),
-    (0x1D1C0, (0xB59, 0x3)),
-    (0x01E37, (0x3CA, 0x2)),
-    (0x2F932, (0xC8E, 0x1)),
-    (0x021AE, (0x815, 0x2)),
-    (0x0FAC6, (0xA99, 0x1)),
-    (0x01F2B, (0x601, 0x3)),
-    (0x0FA3F, (0xA14, 0x1)),
-    (0x0FA54, (0xA29, 0x1)),
-    (0x001DB, (0x16C, 0x3)),
-    (0x01F26, (0x5F4, 0x3)),
-    (0x2F80F, (0xB6B, 0x1)),
-    (0x001F0, (0x198, 0x2)),
-    (0x0FA0B, (0x9EC, 0x1)),
-    (0x2F857, (0xBB3, 0x1)),
-    (0x0FA10, (0x9EF, 0x1)),
-    (0x2FA14, (0xD70, 0x1)),
-    (0x2F8F4, (0xC50, 0x1)),
-    (0x003B0, (0x235, 0x3)),
-    (0x0F9D2, (0x9B3, 0x1)),
-    (0x2F842, (0xB9E, 0x1)),
-    (0x01F9A, (0x725, 0x4)),
-    (0x01EED, (0x579, 0x3)),
-    (0x01ED8, (0x53E, 0x3)),
-    (0x00144, (0x0DA, 0x2)),
-    (0x003D4, (0x244, 0x2)),
-    (0x2F870, (0xBCC, 0x1)),
-    (0x0F95C, (0x93D, 0x1)),
-    (0x0FA92, (0xA65, 0x1)),
-    (0x2F962, (0xCBE, 0x1)),
-    (0x2F8E4, (0xC40, 0x1)),
-    (0x01E15, (0x37F, 0x3)),
-    (0x022E0, (0x859, 0x2)),
-    (0x001D1, (0x152, 0x2)),
-    (0x00165, (0x112, 0x2)),
-    (0x0FAD2, (0xAA5, 0x1)),
-    (0x0FB2C, (0xAB5, 0x3)),
-    (0x01E39, (0x3CF, 0x3)),
-    (0x2F9AE, (0xD0A, 0x1)),
-    (0x000C8, (0x00E, 0x2)),
-    (0x2F8BC, (0xC18, 0x1)),
-    (0x01EEB, (0x573, 0x3)),
-    (0x2F96A, (0xCC6, 0x1)),
-    (0x001FA, (0x1A2, 0x3)),
-    (0x2F8CD, (0xC29, 0x1)),
-    (0x2F8A4, (0xC00, 0x1)),
-    (0x0F91E, (0x8FF, 0x1)),
-    (0x113C7, (0xB0F, 0x2)),
-    (0x01FEF, (0x7F2, 0x1)),
-    (0x2F899, (0xBF5, 0x1)),
-    (0x2F8D8, (0xC34, 0x1)),
-    (0x01E47, (0x3EC, 0x2)),
-    (0x022AE, (0x855, 0x2)),
-    (0x00389, (0x21C, 0x2)),
-    (0x0FA8E, (0xA61, 0x1)),
-    (0x000CC, (0x016, 0x2)),
-    (0x2F81D, (0xB79, 0x1)),
-    (0x0F941, (0x922, 0x1)),
-    (0x0F975, (0x956, 0x1)),
-    (0x00A5A, (0x2E4, 0x2)),
-    (0x00FA2, (0x332, 0x2)),
-    (0x01FB1, (0x77B, 0x2)),
-    (0x00106, (0x076, 0x2)),
-    (0x2F954, (0xCB0, 0x1)),
-    (0x004EB, (0x294, 0x2)),
-    (0x01F72, (0x6AD, 0x2)),
-    (0x2F8AE, (0xC0A, 0x1)),
-    (0x01ED4, (0x532, 0x3)),
-    (0x01E81, (0x474, 0x2)),
-    (0x0FA42, (0xA17, 0x1)),
-    (0x00626, (0x2B6, 0x2)),
-    (0x01E43, (0x3E4, 0x2)),
-    (0x01F77, (0x6B7, 0x2)),
-    (0x001EA, (0x18A, 0x2)),
-    (0x0F9D3, (0x9B4, 0x1)),
-    (0x2F819, (0xB75, 0x1)),
-    (0x2F8BE, (0xC1A, 0x1)),
-    (0x01ED9, (0x541, 0x3)),
-    (0x0F930, (0x911, 0x1)),
-    (0x0FA91, (0xA64, 0x1)),
-    (0x0095F, (0x2D2, 0x2)),
-    (0x2F930, (0xC8C, 0x1)),
-    (0x2F86D, (0xBC9, 0x1)),
-    (0x004EA, (0x292, 0x2)),
-    (0x01EE6, (0x566, 0x2)),
-    (0x01F01, (0x59A, 0x2)),
-    (0x022E2, (0x85D, 0x2)),
-    (0x01FDD, (0x7CB, 0x2)),
-    (0x2FA18, (0xD74, 0x1)),
-    (0x03076, (0x893, 0x2)),
-    (0x2F906, (0xC62, 0x1)),
-    (0x2F9C3, (0xD1F, 0x1)),
-    (0x01F08, (0x5AE, 0x2)),
-    (0x01B3B, (0x348, 0x2)),
-    (0x0022B, (0x1F7, 0x3)),
-    (0x01F86, (0x6DB, 0x4)),
-    (0x000C3, (0x006, 0x2)),
-    (0x0038E, (0x222, 0x2)),
-    (0x004D0, (0x26E, 0x2)),
-    (0x030C7, (0x8BD, 0x2)),
-    (0x00A5B, (0x2E6, 0x2)),
-    (0x000F9, (0x05E, 0x2)),
-    (0x0017D, (0x13E, 0x2)),
-    (0x01E94, (0x49A, 0x2)),
-    (0x01E3D, (0x3D8, 0x2)),
-    (0x0FAB1, (0xA84, 0x1)),
-    (0x2F8DA, (0xC36, 0x1)),
-    (0x01F6F, (0x6A6, 0x3)),
-    (0x0F937, (0x918, 0x1)),
-    (0x2F8EE, (0xC4A, 0x1)),
-    (0x2F8C1, (0xC1D, 0x1)),
-    (0x2F913, (0xC6F, 0x1)),
-    (0x0F912, (0x8F3, 0x1)),
-    (0x2F978, (0xCD4, 0x1)),
-    (0x2F97F, (0xCDB, 0x1)),
-    (0x001EF, (0x196, 0x2)),
-    (0x01E65, (0x433, 0x3)),
-    (0x0012F, (0x0C0, 0x2)),
-    (0x01FC6, (0x79F, 0x2)),
-    (0x0FAC0, (0xA93, 0x1)),
-    (0x0020A, (0x1C4, 0x2)),
-    (0x000C0, (0x000, 0x2)),
-    (0x02209, (0x81F, 0x2)),
-    (0x003CE, (0x240, 0x2)),
-    (0x0020D, (0x1CA, 0x2)),
-    (0x2F99E, (0xCFA, 0x1)),
-    (0x00FA7, (0x334, 0x2)),
-    (0x0F98E, (0x96F, 0x1)),
-    (0x2F805, (0xB61, 0x1)),
-    (0x01EC1, (0x501, 0x3)),
-    (0x00159, (0x0FA, 0x2)),
-    (0x01FCD, (0x7AE, 0x2)),
-    (0x01F40, (0x63C, 0x2)),
-    (0x2F933, (0xC8F, 0x1)),
-    (0x030B0, (0x8A7, 0x2)),
-    (0x01F30, (0x610, 0x2)),
-    (0x00F93, (0x32E, 0x2)),
-    (0x1134C, (0xB03, 0x2)),
-    (0x2FA06, (0xD62, 0x1)),
-    (0x2F9A2, (0xCFE, 0x1)),
-    (0x2F80C, (0xB68, 0x1)),
-    (0x2F9D9, (0xD35, 0x1)),
-    (0x01E19, (0x38A, 0x2)),
-    (0x000C5, (0x00A, 0x2)),
-    (0x01F9F, (0x739, 0x4)),
-    (0x2F95D, (0xCB9, 0x1)),
-    (0x00DDC, (0x311, 0x2)),
-    (0x01F81, (0x6C8, 0x3)),
-    (0x01E76, (0x45A, 0x2)),
-    (0x0F957, (0x938, 0x1)),
-    (0x00134, (0x0C4, 0x2)),
-    (0x01E97, (0x4A0, 0x2)),
-    (0x01EB2, (0x4DA, 0x3)),
-    (0x2F89A, (0xBF6, 0x1)),
-    (0x2F828, (0xB84, 0x1)),
-    (0x0015C, (0x100, 0x2)),
-    (0x0F967, (0x948, 0x1)),
-    (0x00122, (0x0AA, 0x2)),
-    (0x2F967, (0xCC3, 0x1)),
-    (0x00163, (0x10E, 0x2)),
-    (0x0FA2A, (0x9FF, 0x1)),
-    (0x00207, (0x1BE, 0x2)),
-    (0x001D8, (0x163, 0x3)),
-    (0x01F78, (0x6B9, 0x2)),
-    (0x0FA51, (0xA26, 0x1)),
-    (0x2F988, (0xCE4, 0x1)),
-    (0x2F918, (0xC74, 0x1)),
-    (0x030D7, (0x8CB, 0x2)),
-    (0x2F92D, (0xC89, 0x1)),
-    (0x2F9A1, (0xCFD, 0x1)),
-    (0x01F42, (0x640, 0x3)),
-    (0x00160, (0x108, 0x2)),
-    (0x00CC0, (0x2FE, 0x2)),
-    (0x030BA, (0x8B1, 0x2)),
-    (0x01EBE, (0x4F8, 0x3)),
-    (0x01E10, (0x374, 0x2)),
-    (0x01EDE, (0x550, 0x3)),
-    (0x01F57, (0x66F, 0x3)),
-    (0x0F940, (0x921, 0x1)),
-    (0x01E06, (0x35E, 0x2)),
-    (0x0010A, (0x07E, 0x2)),
-    (0x01E46, (0x3EA, 0x2)),
-    (0x0F900, (0x8E1, 0x1)),
-    (0x004EE, (0x29A, 0x2)),
-    (0x2F88C, (0xBE8, 0x1)),
-    (0x2F889, (0xBE5, 0x1)),
-    (0x00FB9, (0x338, 0x2)),
-    (0x2F90C, (0xC68, 0x1)),
-    (0x2F8F1, (0xC4D, 0x1)),
-    (0x00C48, (0x2FC, 0x2)),
-    (0x03067, (0x887, 0x2)),
-    (0x2F917, (0xC73, 0x1)),
-    (0x2F8F3, (0xC4F, 0x1)),
-    (0x2F97A, (0xCD6, 0x1)),
-    (0x0F961, (0x942, 0x1)),
-    (0x0F97C, (0x95D, 0x1)),
-    (0x0037E, (0x214, 0x1)),
-    (0x2F824, (0xB80, 0x1)),
-    (0x004DA, (0x27A, 0x2)),
-    (0x2F89D, (0xBF9, 0x1)),
-    (0x2F960, (0xCBC, 0x1)),
-    (0x0022C, (0x1FA, 0x3)),
-    (0x2F96F, (0xCCB, 0x1)),
-    (0x01F33, (0x617, 0x3)),
-    (0x0FAD5, (0xAA8, 0x1)),
-    (0x2F9F7, (0xD53, 0x1)),
-    (0x16125, (0xB27, 0x2)),
-    (0x2F9AA, (0xD06, 0x1)),
-    (0x022EC, (0x865, 0x2)),
-    (0x00204, (0x1B8, 0x2)),
-    (0x01F3B, (0x62D, 0x3)),
-    (0x2F925, (0xC81, 0x1)),
-    (0x2F8B8, (0xC14, 0x1)),
-    (0x01E8B, (0x488, 0x2)),
-    (0x2F840, (0xB9C, 0x1)),
-    (0x2F931, (0xC8D, 0x1)),
-    (0x00218, (0x1E0, 0x2)),
-    (0x001EB, (0x18C, 0x2)),
-    (0x0F9A6, (0x987, 0x1)),
-    (0x0F976, (0x957, 0x1)),
-    (0x01EA0, (0x4A8, 0x2)),
-    (0x2F86E, (0xBCA, 0x1)),
-    (0x0FA97, (0xA6A, 0x1)),
-    (0x02204, (0x81D, 0x2)),
-    (0x0F9A5, (0x986, 0x1)),
-    (0x01F99, (0x722, 0x3)),
-    (0x01E82, (0x476, 0x2)),
-    (0x01F7D, (0x6C3, 0x2)),
-    (0x001E9, (0x188, 0x2)),
-    (0x2F884, (0xBE0, 0x1)),
-    (0x0020C, (0x1C8, 0x2)),
-    (0x16D69, (0xB34, 0x2)),
-    (0x2F9BC, (0xD18, 0x1)),
-    (0x2F847, (0xBA3, 0x1)),
-    (0x2F8C4, (0xC20, 0x1)),
-    (0x00BCB, (0x2F8, 0x2)),
-    (0x2F830, (0xB8C, 0x1)),
-    (0x01E03, (0x358, 0x2)),
-    (0x01E18, (0x388, 0x2)),
-    (0x030B6, (0x8AD, 0x2)),
-    (0x2F9D4, (0xD30, 0x1)),
-    (0x0F9B7, (0x998, 0x1)),
-    (0x001CE, (0x14C, 0x2)),
-    (0x0F934, (0x915, 0x1)),
-    (0x001B0, (0x148, 0x2)),
-    (0x0011F, (0x0A4, 0x2)),
-    (0x03074, (0x891, 0x2)),
-    (0x2F89C, (0xBF8, 0x1)),
-    (0x00227, (0x1EE, 0x2)),
-    (0x2F979, (0xCD5, 0x1)),
-    (0x2F9F2, (0xD4E, 0x1)),
-    (0x01FA4, (0x74B, 0x4)),
-    (0x2F862, (0xBBE, 0x1)),
-    (0x2F8E5, (0xC41, 0x1)),
-    (0x0016E, (0x120, 0x2)),
-    (0x0F98C, (0x96D, 0x1)),
-    (0x2F95E, (0xCBA, 0x1)),
-    (0x2F996, (0xCF2, 0x1)),
-    (0x01F84, (0x6D3, 0x4)),
-    (0x2F945, (0xCA1, 0x1)),
-    (0x00929, (0x2BE, 0x2)),
-    (0x2F89B, (0xBF7, 0x1)),
-    (0x02224, (0x823, 0x2)),
-    (0x01B08, (0x33E, 0x2)),
-    (0x0F9D6, (0x9B7, 0x1)),
-    (0x01F60, (0x67D, 0x2)),
-    (0x2F953, (0xCAF, 0x1)),
-    (0x01E6E, (0x44A, 0x2)),
-    (0x2F861, (0xBBD, 0x1)),
-    (0x00B5D, (0x2F2, 0x2)),
-    (0x2F938, (0xC94, 0x1)),
-    (0x2F9BD, (0xD19, 0x1)),
-    (0x2F9E4, (0xD40, 0x1)),
-    (0x2F943, (0xC9F, 0x1)),
-    (0x01E3F, (0x3DC, 0x2)),
-    (0x03060, (0x881, 0x2)),
-    (0x2F92F, (0xC8B, 0x1)),
-    (0x2F880, (0xBDC, 0x1)),
-    (0x02262, (0x831, 0x2)),
-    (0x0F9EB, (0x9CC, 0x1)),
-    (0x0F9DC, (0x9BD, 0x1)),
-    (0x01F45, (0x649, 0x3)),
-    (0x0FA6D, (0xA42, 0x1)),
-    (0x01E53, (0x40B, 0x3)),
-    (0x2F88F, (0xBEB, 0x1)),
-    (0x0F956, (0x937, 0x1)),
-    (0x0FA84, (0xA57, 0x1)),
-    (0x001D7, (0x160, 0x3)),
-    (0x113C5, (0xB0D, 0x2)),
-    (0x000E5, (0x03E, 0x2)),
-    (0x01F90, (0x701, 0x3)),
-    (0x2F9A6, (0xD02, 0x1)),
-    (0x01F0E, (0x5BE, 0x3)),
-    (0x0095E, (0x2D0, 0x2)),
-    (0x01E4D, (0x3F9, 0x3)),
-    (0x000D6, (0x028, 0x2)),
-    (0x01F96, (0x717, 0x4)),
-    (0x01EA6, (0x4B6, 0x3)),
-    (0x2F874, (0xBD0, 0x1)),
-    (0x2F9C5, (0xD21, 0x1)),
-    (0x2F981, (0xCDD, 0x1)),
-    (0x0F92B, (0x90C, 0x1)),
-    (0x0FA04, (0x9E5, 0x1)),
-    (0x2F987, (0xCE3, 0x1)),
-    (0x01E64, (0x430, 0x3)),
-    (0x0FB2B, (0xAB3, 0x2)),
-    (0x0FAAB, (0xA7E, 0x1)),
-    (0x2F915, (0xC71, 0x1)),
-    (0x2F81B, (0xB77, 0x1)),
-    (0x00958, (0x2C4, 0x2)),
-    (0x2FA07, (0xD63, 0x1)),
-    (0x0022E, (0x200, 0x2)),
-    (0x0FACC, (0xA9F, 0x1)),
-    (0x2F895, (0xBF1, 0x1)),
-    (0x001E3, (0x180, 0x2)),
-    (0x11385, (0xB07, 0x2)),
-    (0x0FA34, (0xA09, 0x1)),
-    (0x0FAA7, (0xA7A, 0x1)),
-    (0x01F92, (0x707, 0x4)),
-    (0x2F8C9, (0xC25, 0x1)),
-    (0x0FA18, (0x9F4, 0x1)),
-    (0x0F9DA, (0x9BB, 0x1)),
-    (0x2F94B, (0xCA7, 0x1)),
-    (0x0220C, (0x821, 0x2)),
-    (0x0F99E, (0x97F, 0x1)),
-    (0x00F57, (0x31E, 0x2)),
-    (0x00226, (0x1EC, 0x2)),
-    (0x01EB8, (0x4EC, 0x2)),
-    (0x00CCA, (0x304, 0x2)),
-    (0x2F8DF, (0xC3B, 0x1)),
-    (0x0040C, (0x24E, 0x2)),
-    (0x0F926, (0x907, 0x1)),
-    (0x01E85, (0x47C, 0x2)),
-    (0x0015B, (0x0FE, 0x2)),
-    (0x0FA7B, (0xA4E, 0x1)),
-    (0x0FA67, (0xA3C, 0x1)),
-    (0x0F946, (0x927, 0x1)),
-    (0x2F9CD, (0xD29, 0x1)),
-    (0x03054, (0x875, 0x2)),
-    (0x2F868, (0xBC4, 0x1)),
-    (0x0FA7D, (0xA50, 0x1)),
-    (0x01EA5, (0x4B3, 0x3)),
-    (0x2F832, (0xB8E, 0x1)),
-    (0x0FAA0, (0xA73, 0x1)),
-    (0x01FE8, (0x7E4, 0x2)),
-    (0x2F8B1, (0xC0D, 0x1)),
-    (0x00219, (0x1E2, 0x2)),
-    (0x0F9DD, (0x9BE, 0x1)),
-    (0x001DF, (0x175, 0x3)),
-    (0x0FA56, (0xA2B, 0x1)),
-    (0x2F9EC, (0xD48, 0x1)),
-    (0x2F8F5, (0xC51, 0x1)),
-    (0x03050, (0x871, 0x2)),
-    (0x1D163, (0xB46, 0x3)),
-    (0x01EB4, (0x4E0, 0x3)),
-    (0x0F95A, (0x93B, 0x1)),
-    (0x00DDD, (0x313, 0x3)),
-    (0x0FA76, (0xA49, 0x1)),
-    (0x00203, (0x1B6, 0x2)),
-    (0x01B40, (0x34C, 0x2)),
-    (0x004E2, (0x286, 0x2)),
-    (0x01E91, (0x494, 0x2)),
-    (0x2F95A, (0xCB6, 0x1)),
-    (0x0F9E4, (0x9C5, 0x1)),
-    (0x16D6A, (0xB36, 0x3)),
-    (0x0F989, (0x96A, 0x1)),
-    (0x01F03, (0x59F, 0x3)),
-    (0x00154, (0x0F0, 0x2)),
-    (0x000DB, (0x02E, 0x2)),
-    (0x2F923, (0xC7F, 0x1)),
-    (0x00232, (0x20A, 0x2)),
-    (0x00148, (0x0E2, 0x2)),
-    (0x2F87C, (0xBD8, 0x1)),
-    (0x0F9A0, (0x981, 0x1)),
-    (0x0F9CE, (0x9AF, 0x1)),
-    (0x006C2, (0x2BA, 0x2)),
-    (0x0FB41, (0xADB, 0x2)),
-    (0x2F8AA, (0xC06, 0x1)),
-    (0x2F91C, (0xC78, 0x1)),
-    (0x0F990, (0x971, 0x1)),
-    (0x01EE2, (0x55C, 0x3)),
-    (0x01F68, (0x693, 0x2)),
-    (0x01F21, (0x5E6, 0x2)),
-    (0x2F9B7, (0xD13, 0x1)),
-    (0x01FF8, (0x800, 0x2)),
-    (0x0FA09, (0x9EA, 0x1)),
-    (0x030B4, (0x8AB, 0x2)),
-    (0x0FB34, (0xAC7, 0x2)),
-    (0x000C2, (0x004, 0x2)),
-    (0x004E3, (0x288, 0x2)),
-    (0x01E59, (0x418, 0x2)),
-    (0x01B0C, (0x342, 0x2)),
-    (0x2F894, (0xBF0, 0x1)),
-    (0x01E57, (0x414, 0x2)),
-    (0x0021A, (0x1E4, 0x2)),
-    (0x0F9CB, (0x9AC, 0x1)),
-    (0x0226E, (0x835, 0x2)),
-    (0x114BC, (0xB15, 0x2)),
-    (0x2F896, (0xBF2, 0x1)),
-    (0x02274, (0x83D, 0x2)),
-    (0x0FAD6, (0xAA9, 0x1)),
-    (0x02275, (0x83F, 0x2)),
-    (0x0010C, (0x082, 0x2)),
-    (0x2F9B1, (0xD0D, 0x1)),
-    (0x0FB3B, (0xAD3, 0x2)),
-    (0x2F9F1, (0xD4D, 0x1)),
-    (0x00A36, (0x2E0, 0x2)),
-    (0x00BCA, (0x2F6, 0x2)),
-    (0x01ECC, (0x51E, 0x2)),
-    (0x2F958, (0xCB4, 0x1)),
-    (0x0FB35, (0xAC9, 0x2)),
-    (0x001A0, (0x142, 0x2)),
-    (0x0FA19, (0x9F5, 0x1)),
-    (0x0013D, (0x0D4, 0x2)),
-    (0x01EF6, (0x590, 0x2)),
-    (0x0038C, (0x220, 0x2)),
-    (0x2F881, (0xBDD, 0x1)),
-    (0x0F9D9, (0x9BA, 0x1)),
-    (0x01ECD, (0x520, 0x2)),
-    (0x01E7C, (0x46A, 0x2)),
-    (0x2F9DD, (0xD39, 0x1)),
-    (0x16126, (0xB29, 0x3)),
-    (0x2F9ED, (0xD49, 0x1)),
-    (0x2F952, (0xCAE, 0x1)),
-    (0x0F91F, (0x900, 0x1)),
-    (0x2F902, (0xC5E, 0x1)),
-    (0x0F97A, (0x95B, 0x1)),
-    (0x2F8FF, (0xC5B, 0x1)),
-    (0x0FA37, (0xA0C, 0x1)),
-    (0x0FB44, (0xADF, 0x2)),
-    (0x2F9EE, (0xD4A, 0x1)),
-    (0x00A5E, (0x2E8, 0x2)),
-    (0x01F4B, (0x653, 0x3)),
-    (0x0F9F2, (0x9D3, 0x1)),
-    (0x01E6D, (0x448, 0x2)),
-    (0x00164, (0x110, 0x2)),
-    (0x003CD, (0x23E, 0x2)),
-    (0x030FA, (0x8DD, 0x2)),
-    (0x0FAB2, (0xA85, 0x1)),
-    (0x01E40, (0x3DE, 0x2)),
-    (0x00156, (0x0F4, 0x2)),
-    (0x0FA53, (0xA28, 0x1)),
-    (0x2F99F, (0xCFB, 0x1)),
-    (0x2F96D, (0xCC9, 0x1)),
-    (0x2F9A7, (0xD03, 0x1)),
-    (0x01F19, (0x5D6, 0x2)),
-    (0x0F9BA, (0x99B, 0x1)),
-    (0x01EF0, (0x582, 0x3)),
-    (0x2F8D2, (0xC2E, 0x1)),
-    (0x00F5C, (0x320, 0x2)),
-    (0x1D1BD, (0xB50, 0x3)),
-    (0x01FB2, (0x77D, 0x3)),
-    (0x03065, (0x885, 0x2)),
-    (0x2F9DB, (0xD37, 0x1)),
-    (0x0038A, (0x21E, 0x2)),
-    (0x01F91, (0x704, 0x3)),
-    (0x0FB3A, (0xAD1, 0x2)),
-    (0x2F9BE, (0xD1A, 0x1)),
-    (0x01FBA, (0x78E, 0x2)),
-    (0x000F4, (0x058, 0x2)),
-    (0x00B4B, (0x2EC, 0x2)),
-    (0x0F910, (0x8F1, 0x1)),
-    (0x0F95B, (0x93C, 0x1)),
-    (0x2F876, (0xBD2, 0x1)),
-    (0x2F81F, (0xB7B, 0x1)),
-    (0x2F8BD, (0xC19, 0x1)),
-    (0x0F954, (0x935, 0x1)),
-    (0x2F822, (0xB7E, 0x1)),
-    (0x00201, (0x1B2, 0x2)),
-    (0x01E84, (0x47A, 0x2)),
-    (0x2FA08, (0xD64, 0x1)),
-    (0x0F9CF, (0x9B0, 0x1)),
-    (0x2F9A9, (0xD05, 0x1)),
-    (0x01F76, (0x6B5, 0x2)),
-    (0x0F96A, (0x94B, 0x1)),
-    (0x0F9E3, (0x9C4, 0x1)),
-    (0x2F844, (0xBA0, 0x1)),
-    (0x0FB2E, (0xABB, 0x2)),
-    (0x0FAB5, (0xA88, 0x1)),
-    (0x000C1, (0x002, 0x2)),
-    (0x00178, (0x134, 0x2)),
-    (0x2F8D6, (0xC32, 0x1)),
-    (0x00343, (0x210, 0x1)),
-    (0x2F815, (0xB71, 0x1)),
-    (0x2F85F, (0xBBB, 0x1)),
-    (0x0F93B, (0x91C, 0x1)),
-    (0x001F8, (0x19E, 0x2)),
-    (0x01EB6, (0x4E6, 0x3)),
-    (0x01FE7, (0x7E1, 0x3)),
-    (0x0FA47, (0xA1C, 0x1)),
-    (0x2F99B, (0xCF7, 0x1)),
-    (0x004C1, (0x26A, 0x2)),
-    (0x01F49, (0x64E, 0x2)),
-    (0x2F8A9, (0xC05, 0x1)),
-    (0x01E32, (0x3C0, 0x2)),
-    (0x000F2, (0x054, 0x2)),
-    (0x0FA9A, (0xA6D, 0x1)),
-    (0x2F85B, (0xBB7, 0x1)),
-    (0x0F9CD, (0x9AE, 0x1)),
-    (0x030AE, (0x8A5, 0x2)),
-    (0x01F7B, (0x6BF, 0x2)),
-    (0x01E92, (0x496, 0x2)),
-    (0x2F8B2, (0xC0E, 0x1)),
-    (0x0F97E, (0x95F, 0x1)),
-    (0x01EB7, (0x4E9, 0x3)),
-    (0x0FA06, (0x9E7, 0x1)),
-    (0x01FCF, (0x7B2, 0x2)),
-    (0x2F8EA, (0xC46, 0x1)),
-    (0x2F97E, (0xCDA, 0x1)),
-    (0x2F8E2, (0xC3E, 0x1)),
-    (0x01F18, (0x5D4, 0x2)),
-    (0x0F98D, (0x96E, 0x1)),
-    (0x03056, (0x877, 0x2)),
-    (0x2F93A, (0xC96, 0x1)),
-    (0x0FACE, (0xAA1, 0x1)),
-    (0x01E8C, (0x48A, 0x2)),
-    (0x00158, (0x0F8, 0x2)),
-    (0x0FA55, (0xA2A, 0x1)),
-    (0x01FC4, (0x79C, 0x3)),
-    (0x115BA, (0xB19, 0x2)),
-    (0x0017E, (0x140, 0x2)),
-    (0x0010E, (0x086, 0x2)),
-    (0x0F950, (0x931, 0x1)),
-    (0x2F886, (0xBE2, 0x1)),
-    (0x01EF7, (0x592, 0x2)),
-    (0x2F9DC, (0xD38, 0x1)),
-    (0x009DF, (0x2DC, 0x2)),
-    (0x01F8A, (0x6E9, 0x4)),
-    (0x0FAC1, (0xA94, 0x1)),
-    (0x2F934, (0xC90, 0x1)),
-    (0x01EEC, (0x576, 0x3)),
-    (0x01EEF, (0x57F, 0x3)),
-    (0x01F41, (0x63E, 0x2)),
-    (0x0F943, (0x924, 0x1)),
-    (0x01EC7, (0x513, 0x3)),
-    (0x01F66, (0x68D, 0x3)),
-    (0x01F10, (0x5C4, 0x2)),
-    (0x2F8CF, (0xC2B, 0x1)),
-    (0x01FA0, (0x73D, 0x3)),
-    (0x2F909, (0xC65, 0x1)),
-    (0x00FAC, (0x336, 0x2)),
-    (0x004E5, (0x28C, 0x2)),
-    (0x2F991, (0xCED, 0x1)),
-    (0x0F958, (0x939, 0x1)),
-    (0x01FCA, (0x7A8, 0x2)),
-    (0x003CA, (0x238, 0x2)),
-    (0x2F817, (0xB73, 0x1)),
-    (0x00F4D, (0x31A, 0x2)),
-    (0x00143, (0x0D8, 0x2)),
-    (0x0013C, (0x0D2, 0x2)),
-    (0x001F9, (0x1A0, 0x2)),
-    (0x2F9D2, (0xD2E, 0x1)),
-    (0x2F866, (0xBC2, 0x1)),
-    (0x2F9D0, (0xD2C, 0x1)),
-    (0x01E01, (0x354, 0x2)),
-    (0x2F90D, (0xC69, 0x1)),
-    (0x0015A, (0x0FC, 0x2)),
-    (0x00125, (0x0B0, 0x2)),
-    (0x0F984, (0x965, 0x1)),
-    (0x0F91C, (0x8FD, 0x1)),
-    (0x0FA8C, (0xA5F, 0x1)),
-    (0x01E14, (0x37C, 0x3)),
-    (0x0226D, (0x833, 0x2)),
-    (0x0045C, (0x260, 0x2)),
-    (0x00102, (0x06E, 0x2)),
-    (0x0FAAF, (0xA82, 0x1)),
-    (0x2F836, (0xB92, 0x1)),
-    (0x006C0, (0x2B8, 0x2)),
-    (0x0F9FF, (0x9E0, 0x1)),
-    (0x0F97F, (0x960, 0x1)),
-    (0x2F8CA, (0xC26, 0x1)),
-    (0x2F92A, (0xC86, 0x1)),
-    (0x0012B, (0x0B8, 0x2)),
-    (0x0309E, (0x8A1, 0x2)),
-    (0x0FA4E, (0xA23, 0x1)),
-    (0x0FAC8, (0xA9B, 0x1)),
-    (0x01FDF, (0x7CF, 0x2)),
-    (0x2F96E, (0xCCA, 0x1)),
-    (0x00F9D, (0x330, 0x2)),
-    (0x2F802, (0xB5E, 0x1)),
-    (0x01E05, (0x35C, 0x2)),
-    (0x2F80D, (0xB69, 0x1)),
-    (0x2F941, (0xC9D, 0x1)),
-    (0x0021B, (0x1E6, 0x2)),
-    (0x2F82C, (0xB88, 0x1)),
-    (0x0FB46, (0xAE1, 0x2)),
-    (0x0F971, (0x952, 0x1)),
-    (0x0F9C3, (0x9A4, 0x1)),
-    (0x2F83C, (0xB98, 0x1)),
-    (0x2F81A, (0xB76, 0x1)),
-    (0x0F9BB, (0x99C, 0x1)),
-    (0x0FAAC, (0xA7F, 0x1)),
-    (0x01F5F, (0x67A, 0x3)),
-    (0x0FA6A, (0xA3F, 0x1)),
-    (0x2F8B3, (0xC0F, 0x1)),
-    (0x0F9C9, (0x9AA, 0x1)),
-    (0x0F9EE, (0x9CF, 0x1)),
-    (0x01E6B, (0x444, 0x2)),
-    (0x01E2C, (0x3B2, 0x2)),
-    (0x2F851, (0xBAD, 0x1)),
-    (0x2F812, (0xB6E, 0x1)),
-    (0x01F15, (0x5D1, 0x3)),
-    (0x0FA4A, (0xA1F, 0x1)),
-    (0x030DA, (0x8CF, 0x2)),
-    (0x01EC6, (0x510, 0x3)),
-    (0x00208, (0x1C0, 0x2)),
-    (0x0F90B, (0x8EC, 0x1)),
-    (0x01E00, (0x352, 0x2)),
-    (0x0FB40, (0xAD9, 0x2)),
-    (0x2F82D, (0xB89, 0x1)),
-    (0x001D9, (0x166, 0x3)),
-    (0x0FAA5, (0xA78, 0x1)),
-    (0x000F6, (0x05C, 0x2)),
-    (0x022E1, (0x85B, 0x2)),
-    (0x2F961, (0xCBD, 0x1)),
-    (0x021CF, (0x81B, 0x2)),
-    (0x0F9D8, (0x9B9, 0x1)),
-    (0x0FA3D, (0xA12, 0x1)),
-    (0x0FB2F, (0xABD, 0x2)),
-    (0x0FA85, (0xA58, 0x1)),
-    (0x0095C, (0x2CC, 0x2)),
-    (0x01FF7, (0x7FD, 0x3)),
-    (0x01EAE, (0x4CE, 0x3)),
-    (0x2F98E, (0xCEA, 0x1)),
-    (0x01F83, (0x6CF, 0x4)),
-    (0x030C5, (0x8BB, 0x2)),
-    (0x00403, (0x24A, 0x2)),
-    (0x00120, (0x0A6, 0x2)),
-    (0x004F2, (0x2A2, 0x2)),
-    (0x0F98F, (0x970, 0x1)),
-    (0x2F9B0, (0xD0C, 0x1)),
-    (0x01FF3, (0x7F6, 0x2)),
-    (0x00D4A, (0x309, 0x2)),
-    (0x0013A, (0x0CE, 0x2)),
-    (0x01E74, (0x456, 0x2)),
-    (0x2F831, (0xB8D, 0x1)),
-    (0x2F80B, (0xB67, 0x1)),
-    (0x2F8A3, (0xBFF, 0x1)),
-    (0x0F955, (0x936, 0x1)),
-    (0x2F89F, (0xBFB, 0x1)),
-    (0x0011B, (0x09C, 0x2)),
-    (0x0F93C, (0x91D, 0x1)),
-    (0x009DD, (0x2DA, 0x2)),
-    (0x2F9AC, (0xD08, 0x1)),
-    (0x0F933, (0x914, 0x1)),
-    (0x2F8C3, (0xC1F, 0x1)),
-    (0x16121, (0xB1F, 0x2)),
-    (0x2F82A, (0xB86, 0x1)),
-    (0x2F93E, (0xC9A, 0x1)),
-    (0x0022D, (0x1FD, 0x3)),
-    (0x01ED2, (0x52C, 0x3)),
-    (0x2F99D, (0xCF9, 0x1)),
-    (0x01F36, (0x620, 0x3)),
-    (0x2F9D7, (0xD33, 0x1)),
-    (0x01EAD, (0x4CB, 0x3)),
-    (0x2F914, (0xC70, 0x1)),
-    (0x01FE4, (0x7DB, 0x2)),
-    (0x00B5C, (0x2F0, 0x2)),
-    (0x01F95, (0x713, 0x4)),
-    (0x00959, (0x2C6, 0x2)),
-    (0x0F9C0, (0x9A1, 0x1)),
-    (0x01ED7, (0x53B, 0x3)),
-    (0x2F865, (0xBC1, 0x1)),
-    (0x2F801, (0xB5D, 0x1)),
-    (0x01E3E, (0x3DA, 0x2)),
-    (0x2F848, (0xBA4, 0x1)),
-    (0x2F8EF, (0xC4B, 0x1)),
-    (0x2F875, (0xBD1, 0x1)),
-    (0x01E04, (0x35A, 0x2)),
-    (0x0FA1C, (0x9F8, 0x1)),
-    (0x2F807, (0xB63, 0x1)),
-    (0x01ECF, (0x524, 0x2)),
-    (0x01ED1, (0x529, 0x3)),
-    (0x0F927, (0x908, 0x1)),
-    (0x2F8D4, (0xC30, 0x1)),
-    (0x0FA39, (0xA0E, 0x1)),
-    (0x2F989, (0xCE5, 0x1)),
-    (0x2FA0C, (0xD68, 0x1)),
-    (0x2F86A, (0xBC6, 0x1)),
-    (0x01EDC, (0x54A, 0x3)),
-    (0x0F917, (0x8F8, 0x1)),
-    (0x2F8A0, (0xBFC, 0x1)),
-    (0x2F897, (0xBF3, 0x1)),
-    (0x01E38, (0x3CC, 0x3)),
-    (0x000E2, (0x038, 0x2)),
-    (0x01FC9, (0x7A6, 0x2)),
-    (0x01F34, (0x61A, 0x3)),
-    (0x02289, (0x84F, 0x2)),
-    (0x2F9FA, (0xD56, 0x1)),
-    (0x02244, (0x829, 0x2)),
-    (0x0FAA6, (0xA79, 0x1)),
-    (0x2F846, (0xBA2, 0x1)),
-    (0x02126, (0x80D, 0x1)),
-    (0x0010B, (0x080, 0x2)),
-    (0x00145, (0x0DC, 0x2)),
-    (0x00130, (0x0C2, 0x2)),
-    (0x2F9E5, (0xD41, 0x1)),
-    (0x2F912, (0xC6E, 0x1)),
-    (0x0F9AE, (0x98F, 0x1)),
-    (0x2F957, (0xCB3, 0x1)),
-    (0x0F904, (0x8E5, 0x1)),
-    (0x01F98, (0x71F, 0x3)),
-    (0x0F93A, (0x91B, 0x1)),
-    (0x2F8AF, (0xC0B, 0x1)),
-    (0x2F879, (0xBD5, 0x1)),
-    (0x01FF4, (0x7F8, 0x3)),
-    (0x01E23, (0x3A0, 0x2)),
-    (0x00212, (0x1D4, 0x2)),
-    (0x030DD, (0x8D3, 0x2)),
-    (0x2F87B, (0xBD7, 0x1)),
-    (0x2F8EB, (0xC47, 0x1)),
-    (0x01EC2, (0x504, 0x3)),
-    (0x0219A, (0x811, 0x2)),
-    (0x000E1, (0x036, 0x2)),
-    (0x000D1, (0x01E, 0x2)),
-    (0x0F972, (0x953, 0x1)),
-];
-pub(crate) const COMPATIBILITY_DECOMPOSED_CHARS: &[char] = &[
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0308}',
-    '\u{0061}',
-    '\u{0020}',
-    '\u{0304}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0020}',
-    '\u{0301}',
-    '\u{03BC}',
-    '\u{0020}',
-    '\u{0327}',
-    '\u{0031}',
-    '\u{006F}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0034}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{2044}',
-    '\u{0034}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{004C}',
-    '\u{00B7}',
-    '\u{006C}',
-    '\u{00B7}',
-    '\u{02BC}',
-    '\u{006E}',
-    '\u{0073}',
-    '\u{0044}',
-    '\u{005A}',
-    '\u{030C}',
-    '\u{0044}',
-    '\u{007A}',
-    '\u{030C}',
-    '\u{0064}',
-    '\u{007A}',
-    '\u{030C}',
-    '\u{004C}',
-    '\u{004A}',
-    '\u{004C}',
-    '\u{006A}',
-    '\u{006C}',
-    '\u{006A}',
-    '\u{004E}',
-    '\u{004A}',
-    '\u{004E}',
-    '\u{006A}',
-    '\u{006E}',
-    '\u{006A}',
-    '\u{0044}',
-    '\u{005A}',
-    '\u{0044}',
-    '\u{007A}',
-    '\u{0064}',
-    '\u{007A}',
-    '\u{0068}',
-    '\u{0266}',
-    '\u{006A}',
-    '\u{0072}',
-    '\u{0279}',
-    '\u{027B}',
-    '\u{0281}',
-    '\u{0077}',
-    '\u{0079}',
-    '\u{0020}',
-    '\u{0306}',
-    '\u{0020}',
-    '\u{0307}',
-    '\u{0020}',
-    '\u{030A}',
-    '\u{0020}',
-    '\u{0328}',
-    '\u{0020}',
-    '\u{0303}',
-    '\u{0020}',
-    '\u{030B}',
-    '\u{0263}',
-    '\u{006C}',
-    '\u{0073}',
-    '\u{0078}',
-    '\u{0295}',
-    '\u{0020}',
-    '\u{0345}',
-    '\u{0020}',
-    '\u{0301}',
-    '\u{0020}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{03B2}',
-    '\u{03B8}',
-    '\u{03A5}',
-    '\u{03A5}',
-    '\u{0301}',
-    '\u{03A5}',
-    '\u{0308}',
-    '\u{03C6}',
-    '\u{03C0}',
-    '\u{03BA}',
-    '\u{03C1}',
-    '\u{03C2}',
-    '\u{0398}',
-    '\u{03B5}',
-    '\u{03A3}',
-    '\u{0565}',
-    '\u{0582}',
-    '\u{0627}',
-    '\u{0674}',
-    '\u{0648}',
-    '\u{0674}',
-    '\u{06C7}',
-    '\u{0674}',
-    '\u{064A}',
-    '\u{0674}',
-    '\u{0E4D}',
-    '\u{0E32}',
-    '\u{0ECD}',
-    '\u{0EB2}',
-    '\u{0EAB}',
-    '\u{0E99}',
-    '\u{0EAB}',
-    '\u{0EA1}',
-    '\u{0F0B}',
-    '\u{0FB2}',
-    '\u{0F71}',
-    '\u{0F80}',
-    '\u{0FB3}',
-    '\u{0F71}',
-    '\u{0F80}',
-    '\u{10DC}',
-    '\u{0041}',
-    '\u{00C6}',
-    '\u{0042}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{018E}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0222}',
-    '\u{0050}',
-    '\u{0052}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0057}',
-    '\u{0061}',
-    '\u{0250}',
-    '\u{0251}',
-    '\u{1D02}',
-    '\u{0062}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0259}',
-    '\u{025B}',
-    '\u{025C}',
-    '\u{0067}',
-    '\u{006B}',
-    '\u{006D}',
-    '\u{014B}',
-    '\u{006F}',
-    '\u{0254}',
-    '\u{1D16}',
-    '\u{1D17}',
-    '\u{0070}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{1D1D}',
-    '\u{026F}',
-    '\u{0076}',
-    '\u{1D25}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03B4}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{0069}',
-    '\u{0072}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03C1}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{043D}',
-    '\u{0252}',
-    '\u{0063}',
-    '\u{0255}',
-    '\u{00F0}',
-    '\u{025C}',
-    '\u{0066}',
-    '\u{025F}',
-    '\u{0261}',
-    '\u{0265}',
-    '\u{0268}',
-    '\u{0269}',
-    '\u{026A}',
-    '\u{1D7B}',
-    '\u{029D}',
-    '\u{026D}',
-    '\u{1D85}',
-    '\u{029F}',
-    '\u{0271}',
-    '\u{0270}',
-    '\u{0272}',
-    '\u{0273}',
-    '\u{0274}',
-    '\u{0275}',
-    '\u{0278}',
-    '\u{0282}',
-    '\u{0283}',
-    '\u{01AB}',
-    '\u{0289}',
-    '\u{028A}',
-    '\u{1D1C}',
-    '\u{028B}',
-    '\u{028C}',
-    '\u{007A}',
-    '\u{0290}',
-    '\u{0291}',
-    '\u{0292}',
-    '\u{03B8}',
-    '\u{0061}',
-    '\u{02BE}',
-    '\u{0073}',
-    '\u{0307}',
-    '\u{0020}',
-    '\u{0313}',
-    '\u{0020}',
-    '\u{0313}',
-    '\u{0020}',
-    '\u{0342}',
-    '\u{0020}',
-    '\u{0308}',
-    '\u{0342}',
-    '\u{0020}',
-    '\u{0313}',
-    '\u{0300}',
-    '\u{0020}',
-    '\u{0313}',
-    '\u{0301}',
-    '\u{0020}',
-    '\u{0313}',
-    '\u{0342}',
-    '\u{0020}',
-    '\u{0314}',
-    '\u{0300}',
-    '\u{0020}',
-    '\u{0314}',
-    '\u{0301}',
-    '\u{0020}',
-    '\u{0314}',
-    '\u{0342}',
-    '\u{0020}',
-    '\u{0308}',
-    '\u{0300}',
-    '\u{0020}',
-    '\u{0308}',
-    '\u{0301}',
-    '\u{0020}',
-    '\u{0301}',
-    '\u{0020}',
-    '\u{0314}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{0020}',
-    '\u{2010}',
-    '\u{0020}',
-    '\u{0333}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{0020}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{2035}',
-    '\u{2035}',
-    '\u{2035}',
-    '\u{2035}',
-    '\u{2035}',
-    '\u{0021}',
-    '\u{0021}',
-    '\u{0020}',
-    '\u{0305}',
-    '\u{003F}',
-    '\u{003F}',
-    '\u{003F}',
-    '\u{0021}',
-    '\u{0021}',
-    '\u{003F}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{2032}',
-    '\u{0020}',
-    '\u{0030}',
-    '\u{0069}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{002B}',
-    '\u{2212}',
-    '\u{003D}',
-    '\u{0028}',
-    '\u{0029}',
-    '\u{006E}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{002B}',
-    '\u{2212}',
-    '\u{003D}',
-    '\u{0028}',
-    '\u{0029}',
-    '\u{0061}',
-    '\u{0065}',
-    '\u{006F}',
-    '\u{0078}',
-    '\u{0259}',
-    '\u{0068}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{0070}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0052}',
-    '\u{0073}',
-    '\u{0061}',
-    '\u{002F}',
-    '\u{0063}',
-    '\u{0061}',
-    '\u{002F}',
-    '\u{0073}',
-    '\u{0043}',
-    '\u{00B0}',
-    '\u{0043}',
-    '\u{0063}',
-    '\u{002F}',
-    '\u{006F}',
-    '\u{0063}',
-    '\u{002F}',
-    '\u{0075}',
-    '\u{0190}',
-    '\u{00B0}',
-    '\u{0046}',
-    '\u{0067}',
-    '\u{0048}',
-    '\u{0048}',
-    '\u{0048}',
-    '\u{0068}',
-    '\u{0127}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{004C}',
-    '\u{006C}',
-    '\u{004E}',
-    '\u{004E}',
-    '\u{006F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0052}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{004D}',
-    '\u{0054}',
-    '\u{0045}',
-    '\u{004C}',
-    '\u{0054}',
-    '\u{004D}',
-    '\u{005A}',
-    '\u{005A}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0065}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{004D}',
-    '\u{006F}',
-    '\u{05D0}',
-    '\u{05D1}',
-    '\u{05D2}',
-    '\u{05D3}',
-    '\u{0069}',
-    '\u{0046}',
-    '\u{0041}',
-    '\u{0058}',
-    '\u{03C0}',
-    '\u{03B3}',
-    '\u{0393}',
-    '\u{03A0}',
-    '\u{2211}',
-    '\u{0044}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0037}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0039}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0033}',
-    '\u{0032}',
-    '\u{2044}',
-    '\u{0033}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0035}',
-    '\u{0032}',
-    '\u{2044}',
-    '\u{0035}',
-    '\u{0033}',
-    '\u{2044}',
-    '\u{0035}',
-    '\u{0034}',
-    '\u{2044}',
-    '\u{0035}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0036}',
-    '\u{0035}',
-    '\u{2044}',
-    '\u{0036}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0038}',
-    '\u{0033}',
-    '\u{2044}',
-    '\u{0038}',
-    '\u{0035}',
-    '\u{2044}',
-    '\u{0038}',
-    '\u{0037}',
-    '\u{2044}',
-    '\u{0038}',
-    '\u{0031}',
-    '\u{2044}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0056}',
-    '\u{0056}',
-    '\u{0056}',
-    '\u{0049}',
-    '\u{0056}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0056}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{0058}',
-    '\u{0058}',
-    '\u{0058}',
-    '\u{0049}',
-    '\u{0058}',
-    '\u{0049}',
-    '\u{0049}',
-    '\u{004C}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{004D}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0076}',
-    '\u{0076}',
-    '\u{0076}',
-    '\u{0069}',
-    '\u{0076}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0076}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{0078}',
-    '\u{0078}',
-    '\u{0078}',
-    '\u{0069}',
-    '\u{0078}',
-    '\u{0069}',
-    '\u{0069}',
-    '\u{006C}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{006D}',
-    '\u{0030}',
-    '\u{2044}',
-    '\u{0033}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{222E}',
-    '\u{222E}',
-    '\u{222E}',
-    '\u{222E}',
-    '\u{222E}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0031}',
-    '\u{0033}',
-    '\u{0031}',
-    '\u{0034}',
-    '\u{0031}',
-    '\u{0035}',
-    '\u{0031}',
-    '\u{0036}',
-    '\u{0031}',
-    '\u{0037}',
-    '\u{0031}',
-    '\u{0038}',
-    '\u{0031}',
-    '\u{0039}',
-    '\u{0032}',
-    '\u{0030}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0032}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0033}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0034}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0035}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0036}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0037}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0038}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0039}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0033}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0034}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0035}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0036}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0037}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0038}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0031}',
-    '\u{0039}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0032}',
-    '\u{0030}',
-    '\u{0029}',
-    '\u{0031}',
-    '\u{002E}',
-    '\u{0032}',
-    '\u{002E}',
-    '\u{0033}',
-    '\u{002E}',
-    '\u{0034}',
-    '\u{002E}',
-    '\u{0035}',
-    '\u{002E}',
-    '\u{0036}',
-    '\u{002E}',
-    '\u{0037}',
-    '\u{002E}',
-    '\u{0038}',
-    '\u{002E}',
-    '\u{0039}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0033}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0034}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0035}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0036}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0037}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0038}',
-    '\u{002E}',
-    '\u{0031}',
-    '\u{0039}',
-    '\u{002E}',
-    '\u{0032}',
-    '\u{0030}',
-    '\u{002E}',
-    '\u{0028}',
-    '\u{0061}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0062}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0063}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0064}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0065}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0066}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0067}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0068}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0069}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{006A}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{006B}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{006C}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{006D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{006E}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{006F}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0070}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0071}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0072}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0073}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0074}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0075}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0076}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0077}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0078}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0079}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{007A}',
-    '\u{0029}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0030}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{222B}',
-    '\u{003A}',
-    '\u{003A}',
-    '\u{003D}',
-    '\u{003D}',
-    '\u{003D}',
-    '\u{003D}',
-    '\u{003D}',
-    '\u{003D}',
-    '\u{006A}',
-    '\u{0056}',
-    '\u{2D61}',
-    '\u{6BCD}',
-    '\u{9F9F}',
-    '\u{4E00}',
-    '\u{4E28}',
-    '\u{4E36}',
-    '\u{4E3F}',
-    '\u{4E59}',
-    '\u{4E85}',
-    '\u{4E8C}',
-    '\u{4EA0}',
-    '\u{4EBA}',
-    '\u{513F}',
-    '\u{5165}',
-    '\u{516B}',
-    '\u{5182}',
-    '\u{5196}',
-    '\u{51AB}',
-    '\u{51E0}',
-    '\u{51F5}',
-    '\u{5200}',
-    '\u{529B}',
-    '\u{52F9}',
-    '\u{5315}',
-    '\u{531A}',
-    '\u{5338}',
-    '\u{5341}',
-    '\u{535C}',
-    '\u{5369}',
-    '\u{5382}',
-    '\u{53B6}',
-    '\u{53C8}',
-    '\u{53E3}',
-    '\u{56D7}',
-    '\u{571F}',
-    '\u{58EB}',
-    '\u{5902}',
-    '\u{590A}',
-    '\u{5915}',
-    '\u{5927}',
-    '\u{5973}',
-    '\u{5B50}',
-    '\u{5B80}',
-    '\u{5BF8}',
-    '\u{5C0F}',
-    '\u{5C22}',
-    '\u{5C38}',
-    '\u{5C6E}',
-    '\u{5C71}',
-    '\u{5DDB}',
-    '\u{5DE5}',
-    '\u{5DF1}',
-    '\u{5DFE}',
-    '\u{5E72}',
-    '\u{5E7A}',
-    '\u{5E7F}',
-    '\u{5EF4}',
-    '\u{5EFE}',
-    '\u{5F0B}',
-    '\u{5F13}',
-    '\u{5F50}',
-    '\u{5F61}',
-    '\u{5F73}',
-    '\u{5FC3}',
-    '\u{6208}',
-    '\u{6236}',
-    '\u{624B}',
-    '\u{652F}',
-    '\u{6534}',
-    '\u{6587}',
-    '\u{6597}',
-    '\u{65A4}',
-    '\u{65B9}',
-    '\u{65E0}',
-    '\u{65E5}',
-    '\u{66F0}',
-    '\u{6708}',
-    '\u{6728}',
-    '\u{6B20}',
-    '\u{6B62}',
-    '\u{6B79}',
-    '\u{6BB3}',
-    '\u{6BCB}',
-    '\u{6BD4}',
-    '\u{6BDB}',
-    '\u{6C0F}',
-    '\u{6C14}',
-    '\u{6C34}',
-    '\u{706B}',
-    '\u{722A}',
-    '\u{7236}',
-    '\u{723B}',
-    '\u{723F}',
-    '\u{7247}',
-    '\u{7259}',
-    '\u{725B}',
-    '\u{72AC}',
-    '\u{7384}',
-    '\u{7389}',
-    '\u{74DC}',
-    '\u{74E6}',
-    '\u{7518}',
-    '\u{751F}',
-    '\u{7528}',
-    '\u{7530}',
-    '\u{758B}',
-    '\u{7592}',
-    '\u{7676}',
-    '\u{767D}',
-    '\u{76AE}',
-    '\u{76BF}',
-    '\u{76EE}',
-    '\u{77DB}',
-    '\u{77E2}',
-    '\u{77F3}',
-    '\u{793A}',
-    '\u{79B8}',
-    '\u{79BE}',
-    '\u{7A74}',
-    '\u{7ACB}',
-    '\u{7AF9}',
-    '\u{7C73}',
-    '\u{7CF8}',
-    '\u{7F36}',
-    '\u{7F51}',
-    '\u{7F8A}',
-    '\u{7FBD}',
-    '\u{8001}',
-    '\u{800C}',
-    '\u{8012}',
-    '\u{8033}',
-    '\u{807F}',
-    '\u{8089}',
-    '\u{81E3}',
-    '\u{81EA}',
-    '\u{81F3}',
-    '\u{81FC}',
-    '\u{820C}',
-    '\u{821B}',
-    '\u{821F}',
-    '\u{826E}',
-    '\u{8272}',
-    '\u{8278}',
-    '\u{864D}',
-    '\u{866B}',
-    '\u{8840}',
-    '\u{884C}',
-    '\u{8863}',
-    '\u{897E}',
-    '\u{898B}',
-    '\u{89D2}',
-    '\u{8A00}',
-    '\u{8C37}',
-    '\u{8C46}',
-    '\u{8C55}',
-    '\u{8C78}',
-    '\u{8C9D}',
-    '\u{8D64}',
-    '\u{8D70}',
-    '\u{8DB3}',
-    '\u{8EAB}',
-    '\u{8ECA}',
-    '\u{8F9B}',
-    '\u{8FB0}',
-    '\u{8FB5}',
-    '\u{9091}',
-    '\u{9149}',
-    '\u{91C6}',
-    '\u{91CC}',
-    '\u{91D1}',
-    '\u{9577}',
-    '\u{9580}',
-    '\u{961C}',
-    '\u{96B6}',
-    '\u{96B9}',
-    '\u{96E8}',
-    '\u{9751}',
-    '\u{975E}',
-    '\u{9762}',
-    '\u{9769}',
-    '\u{97CB}',
-    '\u{97ED}',
-    '\u{97F3}',
-    '\u{9801}',
-    '\u{98A8}',
-    '\u{98DB}',
-    '\u{98DF}',
-    '\u{9996}',
-    '\u{9999}',
-    '\u{99AC}',
-    '\u{9AA8}',
-    '\u{9AD8}',
-    '\u{9ADF}',
-    '\u{9B25}',
-    '\u{9B2F}',
-    '\u{9B32}',
-    '\u{9B3C}',
-    '\u{9B5A}',
-    '\u{9CE5}',
-    '\u{9E75}',
-    '\u{9E7F}',
-    '\u{9EA5}',
-    '\u{9EBB}',
-    '\u{9EC3}',
-    '\u{9ECD}',
-    '\u{9ED1}',
-    '\u{9EF9}',
-    '\u{9EFD}',
-    '\u{9F0E}',
-    '\u{9F13}',
-    '\u{9F20}',
-    '\u{9F3B}',
-    '\u{9F4A}',
-    '\u{9F52}',
-    '\u{9F8D}',
-    '\u{9F9C}',
-    '\u{9FA0}',
-    '\u{0020}',
-    '\u{3012}',
-    '\u{5341}',
-    '\u{5344}',
-    '\u{5345}',
-    '\u{0020}',
-    '\u{3099}',
-    '\u{0020}',
-    '\u{309A}',
-    '\u{3088}',
-    '\u{308A}',
-    '\u{30B3}',
-    '\u{30C8}',
-    '\u{1100}',
-    '\u{1101}',
-    '\u{11AA}',
-    '\u{1102}',
-    '\u{11AC}',
-    '\u{11AD}',
-    '\u{1103}',
-    '\u{1104}',
-    '\u{1105}',
-    '\u{11B0}',
-    '\u{11B1}',
-    '\u{11B2}',
-    '\u{11B3}',
-    '\u{11B4}',
-    '\u{11B5}',
-    '\u{111A}',
-    '\u{1106}',
-    '\u{1107}',
-    '\u{1108}',
-    '\u{1121}',
-    '\u{1109}',
-    '\u{110A}',
-    '\u{110B}',
-    '\u{110C}',
-    '\u{110D}',
-    '\u{110E}',
-    '\u{110F}',
-    '\u{1110}',
-    '\u{1111}',
-    '\u{1112}',
-    '\u{1161}',
-    '\u{1162}',
-    '\u{1163}',
-    '\u{1164}',
-    '\u{1165}',
-    '\u{1166}',
-    '\u{1167}',
-    '\u{1168}',
-    '\u{1169}',
-    '\u{116A}',
-    '\u{116B}',
-    '\u{116C}',
-    '\u{116D}',
-    '\u{116E}',
-    '\u{116F}',
-    '\u{1170}',
-    '\u{1171}',
-    '\u{1172}',
-    '\u{1173}',
-    '\u{1174}',
-    '\u{1175}',
-    '\u{1160}',
-    '\u{1114}',
-    '\u{1115}',
-    '\u{11C7}',
-    '\u{11C8}',
-    '\u{11CC}',
-    '\u{11CE}',
-    '\u{11D3}',
-    '\u{11D7}',
-    '\u{11D9}',
-    '\u{111C}',
-    '\u{11DD}',
-    '\u{11DF}',
-    '\u{111D}',
-    '\u{111E}',
-    '\u{1120}',
-    '\u{1122}',
-    '\u{1123}',
-    '\u{1127}',
-    '\u{1129}',
-    '\u{112B}',
-    '\u{112C}',
-    '\u{112D}',
-    '\u{112E}',
-    '\u{112F}',
-    '\u{1132}',
-    '\u{1136}',
-    '\u{1140}',
-    '\u{1147}',
-    '\u{114C}',
-    '\u{11F1}',
-    '\u{11F2}',
-    '\u{1157}',
-    '\u{1158}',
-    '\u{1159}',
-    '\u{1184}',
-    '\u{1185}',
-    '\u{1188}',
-    '\u{1191}',
-    '\u{1192}',
-    '\u{1194}',
-    '\u{119E}',
-    '\u{11A1}',
-    '\u{4E00}',
-    '\u{4E8C}',
-    '\u{4E09}',
-    '\u{56DB}',
-    '\u{4E0A}',
-    '\u{4E2D}',
-    '\u{4E0B}',
-    '\u{7532}',
-    '\u{4E59}',
-    '\u{4E19}',
-    '\u{4E01}',
-    '\u{5929}',
-    '\u{5730}',
-    '\u{4EBA}',
-    '\u{0028}',
-    '\u{1100}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1102}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1103}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1105}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1106}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1107}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1109}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110B}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110C}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110E}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110F}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1110}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1111}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1112}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1100}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1102}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1103}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1105}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1106}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1107}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1109}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110B}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110C}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110E}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110F}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1110}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1111}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{1112}',
-    '\u{1161}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110C}',
-    '\u{116E}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110B}',
-    '\u{1169}',
-    '\u{110C}',
-    '\u{1165}',
-    '\u{11AB}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{110B}',
-    '\u{1169}',
-    '\u{1112}',
-    '\u{116E}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4E00}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4E8C}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4E09}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{56DB}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4E94}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{516D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4E03}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{516B}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4E5D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{5341}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{6708}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{706B}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{6C34}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{6728}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{91D1}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{571F}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{65E5}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{682A}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{6709}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{793E}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{540D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{7279}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{8CA1}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{795D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{52B4}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4EE3}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{547C}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{5B66}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{76E3}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4F01}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{8CC7}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{5354}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{796D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{4F11}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{81EA}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{81F3}',
-    '\u{0029}',
-    '\u{554F}',
-    '\u{5E7C}',
-    '\u{6587}',
-    '\u{7B8F}',
-    '\u{0050}',
-    '\u{0054}',
-    '\u{0045}',
-    '\u{0032}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0032}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0032}',
-    '\u{0034}',
-    '\u{0032}',
-    '\u{0035}',
-    '\u{0032}',
-    '\u{0036}',
-    '\u{0032}',
-    '\u{0037}',
-    '\u{0032}',
-    '\u{0038}',
-    '\u{0032}',
-    '\u{0039}',
-    '\u{0033}',
-    '\u{0030}',
-    '\u{0033}',
-    '\u{0031}',
-    '\u{0033}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0033}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0033}',
-    '\u{0035}',
-    '\u{1100}',
-    '\u{1102}',
-    '\u{1103}',
-    '\u{1105}',
-    '\u{1106}',
-    '\u{1107}',
-    '\u{1109}',
-    '\u{110B}',
-    '\u{110C}',
-    '\u{110E}',
-    '\u{110F}',
-    '\u{1110}',
-    '\u{1111}',
-    '\u{1112}',
-    '\u{1100}',
-    '\u{1161}',
-    '\u{1102}',
-    '\u{1161}',
-    '\u{1103}',
-    '\u{1161}',
-    '\u{1105}',
-    '\u{1161}',
-    '\u{1106}',
-    '\u{1161}',
-    '\u{1107}',
-    '\u{1161}',
-    '\u{1109}',
-    '\u{1161}',
-    '\u{110B}',
-    '\u{1161}',
-    '\u{110C}',
-    '\u{1161}',
-    '\u{110E}',
-    '\u{1161}',
-    '\u{110F}',
-    '\u{1161}',
-    '\u{1110}',
-    '\u{1161}',
-    '\u{1111}',
-    '\u{1161}',
-    '\u{1112}',
-    '\u{1161}',
-    '\u{110E}',
-    '\u{1161}',
-    '\u{11B7}',
-    '\u{1100}',
-    '\u{1169}',
-    '\u{110C}',
-    '\u{116E}',
-    '\u{110B}',
-    '\u{1174}',
-    '\u{110B}',
-    '\u{116E}',
-    '\u{4E00}',
-    '\u{4E8C}',
-    '\u{4E09}',
-    '\u{56DB}',
-    '\u{4E94}',
-    '\u{516D}',
-    '\u{4E03}',
-    '\u{516B}',
-    '\u{4E5D}',
-    '\u{5341}',
-    '\u{6708}',
-    '\u{706B}',
-    '\u{6C34}',
-    '\u{6728}',
-    '\u{91D1}',
-    '\u{571F}',
-    '\u{65E5}',
-    '\u{682A}',
-    '\u{6709}',
-    '\u{793E}',
-    '\u{540D}',
-    '\u{7279}',
-    '\u{8CA1}',
-    '\u{795D}',
-    '\u{52B4}',
-    '\u{79D8}',
-    '\u{7537}',
-    '\u{5973}',
-    '\u{9069}',
-    '\u{512A}',
-    '\u{5370}',
-    '\u{6CE8}',
-    '\u{9805}',
-    '\u{4F11}',
-    '\u{5199}',
-    '\u{6B63}',
-    '\u{4E0A}',
-    '\u{4E2D}',
-    '\u{4E0B}',
-    '\u{5DE6}',
-    '\u{53F3}',
-    '\u{533B}',
-    '\u{5B97}',
-    '\u{5B66}',
-    '\u{76E3}',
-    '\u{4F01}',
-    '\u{8CC7}',
-    '\u{5354}',
-    '\u{591C}',
-    '\u{0033}',
-    '\u{0036}',
-    '\u{0033}',
-    '\u{0037}',
-    '\u{0033}',
-    '\u{0038}',
-    '\u{0033}',
-    '\u{0039}',
-    '\u{0034}',
-    '\u{0030}',
-    '\u{0034}',
-    '\u{0031}',
-    '\u{0034}',
-    '\u{0032}',
-    '\u{0034}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0034}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0034}',
-    '\u{0036}',
-    '\u{0034}',
-    '\u{0037}',
-    '\u{0034}',
-    '\u{0038}',
-    '\u{0034}',
-    '\u{0039}',
-    '\u{0035}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{6708}',
-    '\u{0032}',
-    '\u{6708}',
-    '\u{0033}',
-    '\u{6708}',
-    '\u{0034}',
-    '\u{6708}',
-    '\u{0035}',
-    '\u{6708}',
-    '\u{0036}',
-    '\u{6708}',
-    '\u{0037}',
-    '\u{6708}',
-    '\u{0038}',
-    '\u{6708}',
-    '\u{0039}',
-    '\u{6708}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{6708}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{6708}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{6708}',
-    '\u{0048}',
-    '\u{0067}',
-    '\u{0065}',
-    '\u{0072}',
-    '\u{0067}',
-    '\u{0065}',
-    '\u{0056}',
-    '\u{004C}',
-    '\u{0054}',
-    '\u{0044}',
-    '\u{30A2}',
-    '\u{30A4}',
-    '\u{30A6}',
-    '\u{30A8}',
-    '\u{30AA}',
-    '\u{30AB}',
-    '\u{30AD}',
-    '\u{30AF}',
-    '\u{30B1}',
-    '\u{30B3}',
-    '\u{30B5}',
-    '\u{30B7}',
-    '\u{30B9}',
-    '\u{30BB}',
-    '\u{30BD}',
-    '\u{30BF}',
-    '\u{30C1}',
-    '\u{30C4}',
-    '\u{30C6}',
-    '\u{30C8}',
-    '\u{30CA}',
-    '\u{30CB}',
-    '\u{30CC}',
-    '\u{30CD}',
-    '\u{30CE}',
-    '\u{30CF}',
-    '\u{30D2}',
-    '\u{30D5}',
-    '\u{30D8}',
-    '\u{30DB}',
-    '\u{30DE}',
-    '\u{30DF}',
-    '\u{30E0}',
-    '\u{30E1}',
-    '\u{30E2}',
-    '\u{30E4}',
-    '\u{30E6}',
-    '\u{30E8}',
-    '\u{30E9}',
-    '\u{30EA}',
-    '\u{30EB}',
-    '\u{30EC}',
-    '\u{30ED}',
-    '\u{30EF}',
-    '\u{30F0}',
-    '\u{30F1}',
-    '\u{30F2}',
-    '\u{4EE4}',
-    '\u{548C}',
-    '\u{30A2}',
-    '\u{30CF}',
-    '\u{309A}',
-    '\u{30FC}',
-    '\u{30C8}',
-    '\u{30A2}',
-    '\u{30EB}',
-    '\u{30D5}',
-    '\u{30A1}',
-    '\u{30A2}',
-    '\u{30F3}',
-    '\u{30D8}',
-    '\u{309A}',
-    '\u{30A2}',
-    '\u{30A2}',
-    '\u{30FC}',
-    '\u{30EB}',
-    '\u{30A4}',
-    '\u{30CB}',
-    '\u{30F3}',
-    '\u{30AF}',
-    '\u{3099}',
-    '\u{30A4}',
-    '\u{30F3}',
-    '\u{30C1}',
-    '\u{30A6}',
-    '\u{30A9}',
-    '\u{30F3}',
-    '\u{30A8}',
-    '\u{30B9}',
-    '\u{30AF}',
-    '\u{30FC}',
-    '\u{30C8}',
-    '\u{3099}',
-    '\u{30A8}',
-    '\u{30FC}',
-    '\u{30AB}',
-    '\u{30FC}',
-    '\u{30AA}',
-    '\u{30F3}',
-    '\u{30B9}',
-    '\u{30AA}',
-    '\u{30FC}',
-    '\u{30E0}',
-    '\u{30AB}',
-    '\u{30A4}',
-    '\u{30EA}',
-    '\u{30AB}',
-    '\u{30E9}',
-    '\u{30C3}',
-    '\u{30C8}',
-    '\u{30AB}',
-    '\u{30ED}',
-    '\u{30EA}',
-    '\u{30FC}',
-    '\u{30AB}',
-    '\u{3099}',
-    '\u{30ED}',
-    '\u{30F3}',
-    '\u{30AB}',
-    '\u{3099}',
-    '\u{30F3}',
-    '\u{30DE}',
-    '\u{30AD}',
-    '\u{3099}',
-    '\u{30AB}',
-    '\u{3099}',
-    '\u{30AD}',
-    '\u{3099}',
-    '\u{30CB}',
-    '\u{30FC}',
-    '\u{30AD}',
-    '\u{30E5}',
-    '\u{30EA}',
-    '\u{30FC}',
-    '\u{30AD}',
-    '\u{3099}',
-    '\u{30EB}',
-    '\u{30BF}',
-    '\u{3099}',
-    '\u{30FC}',
-    '\u{30AD}',
-    '\u{30ED}',
-    '\u{30AD}',
-    '\u{30ED}',
-    '\u{30AF}',
-    '\u{3099}',
-    '\u{30E9}',
-    '\u{30E0}',
-    '\u{30AD}',
-    '\u{30ED}',
-    '\u{30E1}',
-    '\u{30FC}',
-    '\u{30C8}',
-    '\u{30EB}',
-    '\u{30AD}',
-    '\u{30ED}',
-    '\u{30EF}',
-    '\u{30C3}',
-    '\u{30C8}',
-    '\u{30AF}',
-    '\u{3099}',
-    '\u{30E9}',
-    '\u{30E0}',
-    '\u{30AF}',
-    '\u{3099}',
-    '\u{30E9}',
-    '\u{30E0}',
-    '\u{30C8}',
-    '\u{30F3}',
-    '\u{30AF}',
-    '\u{30EB}',
-    '\u{30BB}',
-    '\u{3099}',
-    '\u{30A4}',
-    '\u{30ED}',
-    '\u{30AF}',
-    '\u{30ED}',
-    '\u{30FC}',
-    '\u{30CD}',
-    '\u{30B1}',
-    '\u{30FC}',
-    '\u{30B9}',
-    '\u{30B3}',
-    '\u{30EB}',
-    '\u{30CA}',
-    '\u{30B3}',
-    '\u{30FC}',
-    '\u{30DB}',
-    '\u{309A}',
-    '\u{30B5}',
-    '\u{30A4}',
-    '\u{30AF}',
-    '\u{30EB}',
-    '\u{30B5}',
-    '\u{30F3}',
-    '\u{30C1}',
-    '\u{30FC}',
-    '\u{30E0}',
-    '\u{30B7}',
-    '\u{30EA}',
-    '\u{30F3}',
-    '\u{30AF}',
-    '\u{3099}',
-    '\u{30BB}',
-    '\u{30F3}',
-    '\u{30C1}',
-    '\u{30BB}',
-    '\u{30F3}',
-    '\u{30C8}',
-    '\u{30BF}',
-    '\u{3099}',
-    '\u{30FC}',
-    '\u{30B9}',
-    '\u{30C6}',
-    '\u{3099}',
-    '\u{30B7}',
-    '\u{30C8}',
-    '\u{3099}',
-    '\u{30EB}',
-    '\u{30C8}',
-    '\u{30F3}',
-    '\u{30CA}',
-    '\u{30CE}',
-    '\u{30CE}',
-    '\u{30C3}',
-    '\u{30C8}',
-    '\u{30CF}',
-    '\u{30A4}',
-    '\u{30C4}',
-    '\u{30CF}',
-    '\u{309A}',
-    '\u{30FC}',
-    '\u{30BB}',
-    '\u{30F3}',
-    '\u{30C8}',
-    '\u{30CF}',
-    '\u{309A}',
-    '\u{30FC}',
-    '\u{30C4}',
-    '\u{30CF}',
-    '\u{3099}',
-    '\u{30FC}',
-    '\u{30EC}',
-    '\u{30EB}',
-    '\u{30D2}',
-    '\u{309A}',
-    '\u{30A2}',
-    '\u{30B9}',
-    '\u{30C8}',
-    '\u{30EB}',
-    '\u{30D2}',
-    '\u{309A}',
-    '\u{30AF}',
-    '\u{30EB}',
-    '\u{30D2}',
-    '\u{309A}',
-    '\u{30B3}',
-    '\u{30D2}',
-    '\u{3099}',
-    '\u{30EB}',
-    '\u{30D5}',
-    '\u{30A1}',
-    '\u{30E9}',
-    '\u{30C3}',
-    '\u{30C8}',
-    '\u{3099}',
-    '\u{30D5}',
-    '\u{30A3}',
-    '\u{30FC}',
-    '\u{30C8}',
-    '\u{30D5}',
-    '\u{3099}',
-    '\u{30C3}',
-    '\u{30B7}',
-    '\u{30A7}',
-    '\u{30EB}',
-    '\u{30D5}',
-    '\u{30E9}',
-    '\u{30F3}',
-    '\u{30D8}',
-    '\u{30AF}',
-    '\u{30BF}',
-    '\u{30FC}',
-    '\u{30EB}',
-    '\u{30D8}',
-    '\u{309A}',
-    '\u{30BD}',
-    '\u{30D8}',
-    '\u{309A}',
-    '\u{30CB}',
-    '\u{30D2}',
-    '\u{30D8}',
-    '\u{30EB}',
-    '\u{30C4}',
-    '\u{30D8}',
-    '\u{309A}',
-    '\u{30F3}',
-    '\u{30B9}',
-    '\u{30D8}',
-    '\u{309A}',
-    '\u{30FC}',
-    '\u{30B7}',
-    '\u{3099}',
-    '\u{30D8}',
-    '\u{3099}',
-    '\u{30FC}',
-    '\u{30BF}',
-    '\u{30DB}',
-    '\u{309A}',
-    '\u{30A4}',
-    '\u{30F3}',
-    '\u{30C8}',
-    '\u{30DB}',
-    '\u{3099}',
-    '\u{30EB}',
-    '\u{30C8}',
-    '\u{30DB}',
-    '\u{30F3}',
-    '\u{30DB}',
-    '\u{309A}',
-    '\u{30F3}',
-    '\u{30C8}',
-    '\u{3099}',
-    '\u{30DB}',
-    '\u{30FC}',
-    '\u{30EB}',
-    '\u{30DB}',
-    '\u{30FC}',
-    '\u{30F3}',
-    '\u{30DE}',
-    '\u{30A4}',
-    '\u{30AF}',
-    '\u{30ED}',
-    '\u{30DE}',
-    '\u{30A4}',
-    '\u{30EB}',
-    '\u{30DE}',
-    '\u{30C3}',
-    '\u{30CF}',
-    '\u{30DE}',
-    '\u{30EB}',
-    '\u{30AF}',
-    '\u{30DE}',
-    '\u{30F3}',
-    '\u{30B7}',
-    '\u{30E7}',
-    '\u{30F3}',
-    '\u{30DF}',
-    '\u{30AF}',
-    '\u{30ED}',
-    '\u{30F3}',
-    '\u{30DF}',
-    '\u{30EA}',
-    '\u{30DF}',
-    '\u{30EA}',
-    '\u{30CF}',
-    '\u{3099}',
-    '\u{30FC}',
-    '\u{30EB}',
-    '\u{30E1}',
-    '\u{30AB}',
-    '\u{3099}',
-    '\u{30E1}',
-    '\u{30AB}',
-    '\u{3099}',
-    '\u{30C8}',
-    '\u{30F3}',
-    '\u{30E1}',
-    '\u{30FC}',
-    '\u{30C8}',
-    '\u{30EB}',
-    '\u{30E4}',
-    '\u{30FC}',
-    '\u{30C8}',
-    '\u{3099}',
-    '\u{30E4}',
-    '\u{30FC}',
-    '\u{30EB}',
-    '\u{30E6}',
-    '\u{30A2}',
-    '\u{30F3}',
-    '\u{30EA}',
-    '\u{30C3}',
-    '\u{30C8}',
-    '\u{30EB}',
-    '\u{30EA}',
-    '\u{30E9}',
-    '\u{30EB}',
-    '\u{30D2}',
-    '\u{309A}',
-    '\u{30FC}',
-    '\u{30EB}',
-    '\u{30FC}',
-    '\u{30D5}',
-    '\u{3099}',
-    '\u{30EB}',
-    '\u{30EC}',
-    '\u{30E0}',
-    '\u{30EC}',
-    '\u{30F3}',
-    '\u{30C8}',
-    '\u{30B1}',
-    '\u{3099}',
-    '\u{30F3}',
-    '\u{30EF}',
-    '\u{30C3}',
-    '\u{30C8}',
-    '\u{0030}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{70B9}',
-    '\u{0032}',
-    '\u{70B9}',
-    '\u{0033}',
-    '\u{70B9}',
-    '\u{0034}',
-    '\u{70B9}',
-    '\u{0035}',
-    '\u{70B9}',
-    '\u{0036}',
-    '\u{70B9}',
-    '\u{0037}',
-    '\u{70B9}',
-    '\u{0038}',
-    '\u{70B9}',
-    '\u{0039}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0033}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0034}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0035}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0036}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0037}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0038}',
-    '\u{70B9}',
-    '\u{0031}',
-    '\u{0039}',
-    '\u{70B9}',
-    '\u{0032}',
-    '\u{0030}',
-    '\u{70B9}',
-    '\u{0032}',
-    '\u{0031}',
-    '\u{70B9}',
-    '\u{0032}',
-    '\u{0032}',
-    '\u{70B9}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{70B9}',
-    '\u{0032}',
-    '\u{0034}',
-    '\u{70B9}',
-    '\u{0068}',
-    '\u{0050}',
-    '\u{0061}',
-    '\u{0064}',
-    '\u{0061}',
-    '\u{0041}',
-    '\u{0055}',
-    '\u{0062}',
-    '\u{0061}',
-    '\u{0072}',
-    '\u{006F}',
-    '\u{0056}',
-    '\u{0070}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{006D}',
-    '\u{0064}',
-    '\u{006D}',
-    '\u{0032}',
-    '\u{0064}',
-    '\u{006D}',
-    '\u{0033}',
-    '\u{0049}',
-    '\u{0055}',
-    '\u{5E73}',
-    '\u{6210}',
-    '\u{662D}',
-    '\u{548C}',
-    '\u{5927}',
-    '\u{6B63}',
-    '\u{660E}',
-    '\u{6CBB}',
-    '\u{682A}',
-    '\u{5F0F}',
-    '\u{4F1A}',
-    '\u{793E}',
-    '\u{0070}',
-    '\u{0041}',
-    '\u{006E}',
-    '\u{0041}',
-    '\u{03BC}',
-    '\u{0041}',
-    '\u{006D}',
-    '\u{0041}',
-    '\u{006B}',
-    '\u{0041}',
-    '\u{004B}',
-    '\u{0042}',
-    '\u{004D}',
-    '\u{0042}',
-    '\u{0047}',
-    '\u{0042}',
-    '\u{0063}',
-    '\u{0061}',
-    '\u{006C}',
-    '\u{006B}',
-    '\u{0063}',
-    '\u{0061}',
-    '\u{006C}',
-    '\u{0070}',
-    '\u{0046}',
-    '\u{006E}',
-    '\u{0046}',
-    '\u{03BC}',
-    '\u{0046}',
-    '\u{03BC}',
-    '\u{0067}',
-    '\u{006D}',
-    '\u{0067}',
-    '\u{006B}',
-    '\u{0067}',
-    '\u{0048}',
-    '\u{007A}',
-    '\u{006B}',
-    '\u{0048}',
-    '\u{007A}',
-    '\u{004D}',
-    '\u{0048}',
-    '\u{007A}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{007A}',
-    '\u{0054}',
-    '\u{0048}',
-    '\u{007A}',
-    '\u{03BC}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006C}',
-    '\u{0064}',
-    '\u{006C}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{0066}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006D}',
-    '\u{03BC}',
-    '\u{006D}',
-    '\u{006D}',
-    '\u{006D}',
-    '\u{0063}',
-    '\u{006D}',
-    '\u{006B}',
-    '\u{006D}',
-    '\u{006D}',
-    '\u{006D}',
-    '\u{0032}',
-    '\u{0063}',
-    '\u{006D}',
-    '\u{0032}',
-    '\u{006D}',
-    '\u{0032}',
-    '\u{006B}',
-    '\u{006D}',
-    '\u{0032}',
-    '\u{006D}',
-    '\u{006D}',
-    '\u{0033}',
-    '\u{0063}',
-    '\u{006D}',
-    '\u{0033}',
-    '\u{006D}',
-    '\u{0033}',
-    '\u{006B}',
-    '\u{006D}',
-    '\u{0033}',
-    '\u{006D}',
-    '\u{2215}',
-    '\u{0073}',
-    '\u{006D}',
-    '\u{2215}',
-    '\u{0073}',
-    '\u{0032}',
-    '\u{0050}',
-    '\u{0061}',
-    '\u{006B}',
-    '\u{0050}',
-    '\u{0061}',
-    '\u{004D}',
-    '\u{0050}',
-    '\u{0061}',
-    '\u{0047}',
-    '\u{0050}',
-    '\u{0061}',
-    '\u{0072}',
-    '\u{0061}',
-    '\u{0064}',
-    '\u{0072}',
-    '\u{0061}',
-    '\u{0064}',
-    '\u{2215}',
-    '\u{0073}',
-    '\u{0072}',
-    '\u{0061}',
-    '\u{0064}',
-    '\u{2215}',
-    '\u{0073}',
-    '\u{0032}',
-    '\u{0070}',
-    '\u{0073}',
-    '\u{006E}',
-    '\u{0073}',
-    '\u{03BC}',
-    '\u{0073}',
-    '\u{006D}',
-    '\u{0073}',
-    '\u{0070}',
-    '\u{0056}',
-    '\u{006E}',
-    '\u{0056}',
-    '\u{03BC}',
-    '\u{0056}',
-    '\u{006D}',
-    '\u{0056}',
-    '\u{006B}',
-    '\u{0056}',
-    '\u{004D}',
-    '\u{0056}',
-    '\u{0070}',
-    '\u{0057}',
-    '\u{006E}',
-    '\u{0057}',
-    '\u{03BC}',
-    '\u{0057}',
-    '\u{006D}',
-    '\u{0057}',
-    '\u{006B}',
-    '\u{0057}',
-    '\u{004D}',
-    '\u{0057}',
-    '\u{006B}',
-    '\u{03A9}',
-    '\u{004D}',
-    '\u{03A9}',
-    '\u{0061}',
-    '\u{002E}',
-    '\u{006D}',
-    '\u{002E}',
-    '\u{0042}',
-    '\u{0071}',
-    '\u{0063}',
-    '\u{0063}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0043}',
-    '\u{2215}',
-    '\u{006B}',
-    '\u{0067}',
-    '\u{0043}',
-    '\u{006F}',
-    '\u{002E}',
-    '\u{0064}',
-    '\u{0042}',
-    '\u{0047}',
-    '\u{0079}',
-    '\u{0068}',
-    '\u{0061}',
-    '\u{0048}',
-    '\u{0050}',
-    '\u{0069}',
-    '\u{006E}',
-    '\u{004B}',
-    '\u{004B}',
-    '\u{004B}',
-    '\u{004D}',
-    '\u{006B}',
-    '\u{0074}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006C}',
-    '\u{006E}',
-    '\u{006C}',
-    '\u{006F}',
-    '\u{0067}',
-    '\u{006C}',
-    '\u{0078}',
-    '\u{006D}',
-    '\u{0062}',
-    '\u{006D}',
-    '\u{0069}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006F}',
-    '\u{006C}',
-    '\u{0050}',
-    '\u{0048}',
-    '\u{0070}',
-    '\u{002E}',
-    '\u{006D}',
-    '\u{002E}',
-    '\u{0050}',
-    '\u{0050}',
-    '\u{004D}',
-    '\u{0050}',
-    '\u{0052}',
-    '\u{0073}',
-    '\u{0072}',
-    '\u{0053}',
-    '\u{0076}',
-    '\u{0057}',
-    '\u{0062}',
-    '\u{0056}',
-    '\u{2215}',
-    '\u{006D}',
-    '\u{0041}',
-    '\u{2215}',
-    '\u{006D}',
-    '\u{0031}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{65E5}',
-    '\u{0033}',
-    '\u{65E5}',
-    '\u{0034}',
-    '\u{65E5}',
-    '\u{0035}',
-    '\u{65E5}',
-    '\u{0036}',
-    '\u{65E5}',
-    '\u{0037}',
-    '\u{65E5}',
-    '\u{0038}',
-    '\u{65E5}',
-    '\u{0039}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0030}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0031}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0033}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0034}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0035}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0036}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0037}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0038}',
-    '\u{65E5}',
-    '\u{0031}',
-    '\u{0039}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0030}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0031}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0032}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0034}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0035}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0036}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0037}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0038}',
-    '\u{65E5}',
-    '\u{0032}',
-    '\u{0039}',
-    '\u{65E5}',
-    '\u{0033}',
-    '\u{0030}',
-    '\u{65E5}',
-    '\u{0033}',
-    '\u{0031}',
-    '\u{65E5}',
-    '\u{0067}',
-    '\u{0061}',
-    '\u{006C}',
-    '\u{044A}',
-    '\u{044C}',
-    '\u{A76F}',
-    '\u{0043}',
-    '\u{0046}',
-    '\u{0051}',
-    '\u{0126}',
-    '\u{0153}',
-    '\u{A727}',
-    '\u{AB37}',
-    '\u{026B}',
-    '\u{AB52}',
-    '\u{028D}',
-    '\u{0066}',
-    '\u{0066}',
-    '\u{0066}',
-    '\u{0069}',
-    '\u{0066}',
-    '\u{006C}',
-    '\u{0066}',
-    '\u{0066}',
-    '\u{0069}',
-    '\u{0066}',
-    '\u{0066}',
-    '\u{006C}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0574}',
-    '\u{0576}',
-    '\u{0574}',
-    '\u{0565}',
-    '\u{0574}',
-    '\u{056B}',
-    '\u{057E}',
-    '\u{0576}',
-    '\u{0574}',
-    '\u{056D}',
-    '\u{05E2}',
-    '\u{05D0}',
-    '\u{05D3}',
-    '\u{05D4}',
-    '\u{05DB}',
-    '\u{05DC}',
-    '\u{05DD}',
-    '\u{05E8}',
-    '\u{05EA}',
-    '\u{002B}',
-    '\u{05D0}',
-    '\u{05DC}',
-    '\u{0671}',
-    '\u{0671}',
-    '\u{067B}',
-    '\u{067B}',
-    '\u{067B}',
-    '\u{067B}',
-    '\u{067E}',
-    '\u{067E}',
-    '\u{067E}',
-    '\u{067E}',
-    '\u{0680}',
-    '\u{0680}',
-    '\u{0680}',
-    '\u{0680}',
-    '\u{067A}',
-    '\u{067A}',
-    '\u{067A}',
-    '\u{067A}',
-    '\u{067F}',
-    '\u{067F}',
-    '\u{067F}',
-    '\u{067F}',
-    '\u{0679}',
-    '\u{0679}',
-    '\u{0679}',
-    '\u{0679}',
-    '\u{06A4}',
-    '\u{06A4}',
-    '\u{06A4}',
-    '\u{06A4}',
-    '\u{06A6}',
-    '\u{06A6}',
-    '\u{06A6}',
-    '\u{06A6}',
-    '\u{0684}',
-    '\u{0684}',
-    '\u{0684}',
-    '\u{0684}',
-    '\u{0683}',
-    '\u{0683}',
-    '\u{0683}',
-    '\u{0683}',
-    '\u{0686}',
-    '\u{0686}',
-    '\u{0686}',
-    '\u{0686}',
-    '\u{0687}',
-    '\u{0687}',
-    '\u{0687}',
-    '\u{0687}',
-    '\u{068D}',
-    '\u{068D}',
-    '\u{068C}',
-    '\u{068C}',
-    '\u{068E}',
-    '\u{068E}',
-    '\u{0688}',
-    '\u{0688}',
-    '\u{0698}',
-    '\u{0698}',
-    '\u{0691}',
-    '\u{0691}',
-    '\u{06A9}',
-    '\u{06A9}',
-    '\u{06A9}',
-    '\u{06A9}',
-    '\u{06AF}',
-    '\u{06AF}',
-    '\u{06AF}',
-    '\u{06AF}',
-    '\u{06B3}',
-    '\u{06B3}',
-    '\u{06B3}',
-    '\u{06B3}',
-    '\u{06B1}',
-    '\u{06B1}',
-    '\u{06B1}',
-    '\u{06B1}',
-    '\u{06BA}',
-    '\u{06BA}',
-    '\u{06BB}',
-    '\u{06BB}',
-    '\u{06BB}',
-    '\u{06BB}',
-    '\u{06D5}',
-    '\u{0654}',
-    '\u{06D5}',
-    '\u{0654}',
-    '\u{06C1}',
-    '\u{06C1}',
-    '\u{06C1}',
-    '\u{06C1}',
-    '\u{06BE}',
-    '\u{06BE}',
-    '\u{06BE}',
-    '\u{06BE}',
-    '\u{06D2}',
-    '\u{06D2}',
-    '\u{06D2}',
-    '\u{0654}',
-    '\u{06D2}',
-    '\u{0654}',
-    '\u{06AD}',
-    '\u{06AD}',
-    '\u{06AD}',
-    '\u{06AD}',
-    '\u{06C7}',
-    '\u{06C7}',
-    '\u{06C6}',
-    '\u{06C6}',
-    '\u{06C8}',
-    '\u{06C8}',
-    '\u{06C7}',
-    '\u{0674}',
-    '\u{06CB}',
-    '\u{06CB}',
-    '\u{06C5}',
-    '\u{06C5}',
-    '\u{06C9}',
-    '\u{06C9}',
-    '\u{06D0}',
-    '\u{06D0}',
-    '\u{06D0}',
-    '\u{06D0}',
-    '\u{0649}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0627}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0627}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06D5}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06D5}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0648}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0648}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06C7}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06C7}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06C6}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06C6}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06C8}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06C8}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06D0}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06D0}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{06D0}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0649}',
-    '\u{06CC}',
-    '\u{06CC}',
-    '\u{06CC}',
-    '\u{06CC}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{064A}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{0628}',
-    '\u{062D}',
-    '\u{0628}',
-    '\u{062E}',
-    '\u{0628}',
-    '\u{0645}',
-    '\u{0628}',
-    '\u{0649}',
-    '\u{0628}',
-    '\u{064A}',
-    '\u{062A}',
-    '\u{062C}',
-    '\u{062A}',
-    '\u{062D}',
-    '\u{062A}',
-    '\u{062E}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{0649}',
-    '\u{062A}',
-    '\u{064A}',
-    '\u{062B}',
-    '\u{062C}',
-    '\u{062B}',
-    '\u{0645}',
-    '\u{062B}',
-    '\u{0649}',
-    '\u{062B}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{062C}',
-    '\u{062E}',
-    '\u{062D}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{062C}',
-    '\u{0633}',
-    '\u{062D}',
-    '\u{0633}',
-    '\u{062E}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{0635}',
-    '\u{062D}',
-    '\u{0635}',
-    '\u{0645}',
-    '\u{0636}',
-    '\u{062C}',
-    '\u{0636}',
-    '\u{062D}',
-    '\u{0636}',
-    '\u{062E}',
-    '\u{0636}',
-    '\u{0645}',
-    '\u{0637}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{0638}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{062C}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{063A}',
-    '\u{062C}',
-    '\u{063A}',
-    '\u{0645}',
-    '\u{0641}',
-    '\u{062C}',
-    '\u{0641}',
-    '\u{062D}',
-    '\u{0641}',
-    '\u{062E}',
-    '\u{0641}',
-    '\u{0645}',
-    '\u{0641}',
-    '\u{0649}',
-    '\u{0641}',
-    '\u{064A}',
-    '\u{0642}',
-    '\u{062D}',
-    '\u{0642}',
-    '\u{0645}',
-    '\u{0642}',
-    '\u{0649}',
-    '\u{0642}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0627}',
-    '\u{0643}',
-    '\u{062C}',
-    '\u{0643}',
-    '\u{062D}',
-    '\u{0643}',
-    '\u{062E}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0643}',
-    '\u{0649}',
-    '\u{0643}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{0644}',
-    '\u{062D}',
-    '\u{0644}',
-    '\u{062E}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{0649}',
-    '\u{0644}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{0646}',
-    '\u{062D}',
-    '\u{0646}',
-    '\u{062E}',
-    '\u{0646}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0649}',
-    '\u{0646}',
-    '\u{064A}',
-    '\u{0647}',
-    '\u{062C}',
-    '\u{0647}',
-    '\u{0645}',
-    '\u{0647}',
-    '\u{0649}',
-    '\u{0647}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{0630}',
-    '\u{0670}',
-    '\u{0631}',
-    '\u{0670}',
-    '\u{0649}',
-    '\u{0670}',
-    '\u{0020}',
-    '\u{064C}',
-    '\u{0651}',
-    '\u{0020}',
-    '\u{064D}',
-    '\u{0651}',
-    '\u{0020}',
-    '\u{064E}',
-    '\u{0651}',
-    '\u{0020}',
-    '\u{064F}',
-    '\u{0651}',
-    '\u{0020}',
-    '\u{0650}',
-    '\u{0651}',
-    '\u{0020}',
-    '\u{0651}',
-    '\u{0670}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0631}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0632}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0646}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{064A}',
-    '\u{0628}',
-    '\u{0631}',
-    '\u{0628}',
-    '\u{0632}',
-    '\u{0628}',
-    '\u{0645}',
-    '\u{0628}',
-    '\u{0646}',
-    '\u{0628}',
-    '\u{0649}',
-    '\u{0628}',
-    '\u{064A}',
-    '\u{062A}',
-    '\u{0631}',
-    '\u{062A}',
-    '\u{0632}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{0646}',
-    '\u{062A}',
-    '\u{0649}',
-    '\u{062A}',
-    '\u{064A}',
-    '\u{062B}',
-    '\u{0631}',
-    '\u{062B}',
-    '\u{0632}',
-    '\u{062B}',
-    '\u{0645}',
-    '\u{062B}',
-    '\u{0646}',
-    '\u{062B}',
-    '\u{0649}',
-    '\u{062B}',
-    '\u{064A}',
-    '\u{0641}',
-    '\u{0649}',
-    '\u{0641}',
-    '\u{064A}',
-    '\u{0642}',
-    '\u{0649}',
-    '\u{0642}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0627}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0643}',
-    '\u{0649}',
-    '\u{0643}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{0649}',
-    '\u{0644}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{0627}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0631}',
-    '\u{0646}',
-    '\u{0632}',
-    '\u{0646}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0646}',
-    '\u{0646}',
-    '\u{0649}',
-    '\u{0646}',
-    '\u{064A}',
-    '\u{0649}',
-    '\u{0670}',
-    '\u{064A}',
-    '\u{0631}',
-    '\u{064A}',
-    '\u{0632}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0646}',
-    '\u{064A}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0647}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{0628}',
-    '\u{062D}',
-    '\u{0628}',
-    '\u{062E}',
-    '\u{0628}',
-    '\u{0645}',
-    '\u{0628}',
-    '\u{0647}',
-    '\u{062A}',
-    '\u{062C}',
-    '\u{062A}',
-    '\u{062D}',
-    '\u{062A}',
-    '\u{062E}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{0647}',
-    '\u{062B}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{062C}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{062C}',
-    '\u{0633}',
-    '\u{062D}',
-    '\u{0633}',
-    '\u{062E}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{0635}',
-    '\u{062D}',
-    '\u{0635}',
-    '\u{062E}',
-    '\u{0635}',
-    '\u{0645}',
-    '\u{0636}',
-    '\u{062C}',
-    '\u{0636}',
-    '\u{062D}',
-    '\u{0636}',
-    '\u{062E}',
-    '\u{0636}',
-    '\u{0645}',
-    '\u{0637}',
-    '\u{062D}',
-    '\u{0638}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{062C}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{063A}',
-    '\u{062C}',
-    '\u{063A}',
-    '\u{0645}',
-    '\u{0641}',
-    '\u{062C}',
-    '\u{0641}',
-    '\u{062D}',
-    '\u{0641}',
-    '\u{062E}',
-    '\u{0641}',
-    '\u{0645}',
-    '\u{0642}',
-    '\u{062D}',
-    '\u{0642}',
-    '\u{0645}',
-    '\u{0643}',
-    '\u{062C}',
-    '\u{0643}',
-    '\u{062D}',
-    '\u{0643}',
-    '\u{062E}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{0644}',
-    '\u{062D}',
-    '\u{0644}',
-    '\u{062E}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{0647}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{0646}',
-    '\u{062D}',
-    '\u{0646}',
-    '\u{062E}',
-    '\u{0646}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0647}',
-    '\u{0647}',
-    '\u{062C}',
-    '\u{0647}',
-    '\u{0645}',
-    '\u{0647}',
-    '\u{0670}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0647}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0647}',
-    '\u{0628}',
-    '\u{0645}',
-    '\u{0628}',
-    '\u{0647}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{0647}',
-    '\u{062B}',
-    '\u{0645}',
-    '\u{062B}',
-    '\u{0647}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{0647}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{0647}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0647}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0647}',
-    '\u{0640}',
-    '\u{064E}',
-    '\u{0651}',
-    '\u{0640}',
-    '\u{064F}',
-    '\u{0651}',
-    '\u{0640}',
-    '\u{0650}',
-    '\u{0651}',
-    '\u{0637}',
-    '\u{0649}',
-    '\u{0637}',
-    '\u{064A}',
-    '\u{0639}',
-    '\u{0649}',
-    '\u{0639}',
-    '\u{064A}',
-    '\u{063A}',
-    '\u{0649}',
-    '\u{063A}',
-    '\u{064A}',
-    '\u{0633}',
-    '\u{0649}',
-    '\u{0633}',
-    '\u{064A}',
-    '\u{0634}',
-    '\u{0649}',
-    '\u{0634}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{0649}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{0649}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{062E}',
-    '\u{0649}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0635}',
-    '\u{0649}',
-    '\u{0635}',
-    '\u{064A}',
-    '\u{0636}',
-    '\u{0649}',
-    '\u{0636}',
-    '\u{064A}',
-    '\u{0634}',
-    '\u{062C}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{0634}',
-    '\u{062E}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{0631}',
-    '\u{0633}',
-    '\u{0631}',
-    '\u{0635}',
-    '\u{0631}',
-    '\u{0636}',
-    '\u{0631}',
-    '\u{0637}',
-    '\u{0649}',
-    '\u{0637}',
-    '\u{064A}',
-    '\u{0639}',
-    '\u{0649}',
-    '\u{0639}',
-    '\u{064A}',
-    '\u{063A}',
-    '\u{0649}',
-    '\u{063A}',
-    '\u{064A}',
-    '\u{0633}',
-    '\u{0649}',
-    '\u{0633}',
-    '\u{064A}',
-    '\u{0634}',
-    '\u{0649}',
-    '\u{0634}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{0649}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{0649}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{062E}',
-    '\u{0649}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0635}',
-    '\u{0649}',
-    '\u{0635}',
-    '\u{064A}',
-    '\u{0636}',
-    '\u{0649}',
-    '\u{0636}',
-    '\u{064A}',
-    '\u{0634}',
-    '\u{062C}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{0634}',
-    '\u{062E}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{0631}',
-    '\u{0633}',
-    '\u{0631}',
-    '\u{0635}',
-    '\u{0631}',
-    '\u{0636}',
-    '\u{0631}',
-    '\u{0634}',
-    '\u{062C}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{0634}',
-    '\u{062E}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{0647}',
-    '\u{0634}',
-    '\u{0647}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{062C}',
-    '\u{0633}',
-    '\u{062D}',
-    '\u{0633}',
-    '\u{062E}',
-    '\u{0634}',
-    '\u{062C}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{0634}',
-    '\u{062E}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{0638}',
-    '\u{0645}',
-    '\u{0627}',
-    '\u{064B}',
-    '\u{0627}',
-    '\u{064B}',
-    '\u{062A}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{062A}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{062A}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{0633}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{0633}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{0633}',
-    '\u{062C}',
-    '\u{0649}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0635}',
-    '\u{062D}',
-    '\u{062D}',
-    '\u{0635}',
-    '\u{062D}',
-    '\u{062D}',
-    '\u{0635}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0634}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0636}',
-    '\u{062D}',
-    '\u{0649}',
-    '\u{0636}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0636}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0637}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0639}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{063A}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{063A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{063A}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{0641}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0641}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0642}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0642}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{062D}',
-    '\u{0649}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{062C}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{062C}',
-    '\u{0644}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{062E}',
-    '\u{0647}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{0647}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{062D}',
-    '\u{0649}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{0649}',
-    '\u{0646}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0646}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0628}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{062A}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{062A}',
-    '\u{062C}',
-    '\u{0649}',
-    '\u{062A}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{062A}',
-    '\u{062E}',
-    '\u{0649}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{062A}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{0649}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0649}',
-    '\u{0633}',
-    '\u{062E}',
-    '\u{0649}',
-    '\u{0635}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0634}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0636}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0642}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0646}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0642}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0644}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0644}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{062D}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0641}',
-    '\u{0645}',
-    '\u{064A}',
-    '\u{0628}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0639}',
-    '\u{062C}',
-    '\u{0645}',
-    '\u{0635}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0633}',
-    '\u{062E}',
-    '\u{064A}',
-    '\u{0646}',
-    '\u{062C}',
-    '\u{064A}',
-    '\u{0635}',
-    '\u{0644}',
-    '\u{06D2}',
-    '\u{0642}',
-    '\u{0644}',
-    '\u{06D2}',
-    '\u{0627}',
-    '\u{0644}',
-    '\u{0644}',
-    '\u{0647}',
-    '\u{0627}',
-    '\u{0643}',
-    '\u{0628}',
-    '\u{0631}',
-    '\u{0645}',
-    '\u{062D}',
-    '\u{0645}',
-    '\u{062F}',
-    '\u{0635}',
-    '\u{0644}',
-    '\u{0639}',
-    '\u{0645}',
-    '\u{0631}',
-    '\u{0633}',
-    '\u{0648}',
-    '\u{0644}',
-    '\u{0639}',
-    '\u{0644}',
-    '\u{064A}',
-    '\u{0647}',
-    '\u{0648}',
-    '\u{0633}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0635}',
-    '\u{0644}',
-    '\u{0649}',
-    '\u{0635}',
-    '\u{0644}',
-    '\u{0649}',
-    '\u{0020}',
-    '\u{0627}',
-    '\u{0644}',
-    '\u{0644}',
-    '\u{0647}',
-    '\u{0020}',
-    '\u{0639}',
-    '\u{0644}',
-    '\u{064A}',
-    '\u{0647}',
-    '\u{0020}',
-    '\u{0648}',
-    '\u{0633}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{062C}',
-    '\u{0644}',
-    '\u{0020}',
-    '\u{062C}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0644}',
-    '\u{0647}',
-    '\u{0631}',
-    '\u{06CC}',
-    '\u{0627}',
-    '\u{0644}',
-    '\u{002C}',
-    '\u{3001}',
-    '\u{3002}',
-    '\u{003A}',
-    '\u{003B}',
-    '\u{0021}',
-    '\u{003F}',
-    '\u{3016}',
-    '\u{3017}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{002E}',
-    '\u{2014}',
-    '\u{2013}',
-    '\u{005F}',
-    '\u{005F}',
-    '\u{0028}',
-    '\u{0029}',
-    '\u{007B}',
-    '\u{007D}',
-    '\u{3014}',
-    '\u{3015}',
-    '\u{3010}',
-    '\u{3011}',
-    '\u{300A}',
-    '\u{300B}',
-    '\u{3008}',
-    '\u{3009}',
-    '\u{300C}',
-    '\u{300D}',
-    '\u{300E}',
-    '\u{300F}',
-    '\u{005B}',
-    '\u{005D}',
-    '\u{0020}',
-    '\u{0305}',
-    '\u{0020}',
-    '\u{0305}',
-    '\u{0020}',
-    '\u{0305}',
-    '\u{0020}',
-    '\u{0305}',
-    '\u{005F}',
-    '\u{005F}',
-    '\u{005F}',
-    '\u{002C}',
-    '\u{3001}',
-    '\u{002E}',
-    '\u{003B}',
-    '\u{003A}',
-    '\u{003F}',
-    '\u{0021}',
-    '\u{2014}',
-    '\u{0028}',
-    '\u{0029}',
-    '\u{007B}',
-    '\u{007D}',
-    '\u{3014}',
-    '\u{3015}',
-    '\u{0023}',
-    '\u{0026}',
-    '\u{002A}',
-    '\u{002B}',
-    '\u{002D}',
-    '\u{003C}',
-    '\u{003E}',
-    '\u{003D}',
-    '\u{005C}',
-    '\u{0024}',
-    '\u{0025}',
-    '\u{0040}',
-    '\u{0020}',
-    '\u{064B}',
-    '\u{0640}',
-    '\u{064B}',
-    '\u{0020}',
-    '\u{064C}',
-    '\u{0020}',
-    '\u{064D}',
-    '\u{0020}',
-    '\u{064E}',
-    '\u{0640}',
-    '\u{064E}',
-    '\u{0020}',
-    '\u{064F}',
-    '\u{0640}',
-    '\u{064F}',
-    '\u{0020}',
-    '\u{0650}',
-    '\u{0640}',
-    '\u{0650}',
-    '\u{0020}',
-    '\u{0651}',
-    '\u{0640}',
-    '\u{0651}',
-    '\u{0020}',
-    '\u{0652}',
-    '\u{0640}',
-    '\u{0652}',
-    '\u{0621}',
-    '\u{0627}',
-    '\u{0653}',
-    '\u{0627}',
-    '\u{0653}',
-    '\u{0627}',
-    '\u{0654}',
-    '\u{0627}',
-    '\u{0654}',
-    '\u{0648}',
-    '\u{0654}',
-    '\u{0648}',
-    '\u{0654}',
-    '\u{0627}',
-    '\u{0655}',
-    '\u{0627}',
-    '\u{0655}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{064A}',
-    '\u{0654}',
-    '\u{0627}',
-    '\u{0627}',
-    '\u{0628}',
-    '\u{0628}',
-    '\u{0628}',
-    '\u{0628}',
-    '\u{0629}',
-    '\u{0629}',
-    '\u{062A}',
-    '\u{062A}',
-    '\u{062A}',
-    '\u{062A}',
-    '\u{062B}',
-    '\u{062B}',
-    '\u{062B}',
-    '\u{062B}',
-    '\u{062C}',
-    '\u{062C}',
-    '\u{062C}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{062D}',
-    '\u{062D}',
-    '\u{062D}',
-    '\u{062E}',
-    '\u{062E}',
-    '\u{062E}',
-    '\u{062E}',
-    '\u{062F}',
-    '\u{062F}',
-    '\u{0630}',
-    '\u{0630}',
-    '\u{0631}',
-    '\u{0631}',
-    '\u{0632}',
-    '\u{0632}',
-    '\u{0633}',
-    '\u{0633}',
-    '\u{0633}',
-    '\u{0633}',
-    '\u{0634}',
-    '\u{0634}',
-    '\u{0634}',
-    '\u{0634}',
-    '\u{0635}',
-    '\u{0635}',
-    '\u{0635}',
-    '\u{0635}',
-    '\u{0636}',
-    '\u{0636}',
-    '\u{0636}',
-    '\u{0636}',
-    '\u{0637}',
-    '\u{0637}',
-    '\u{0637}',
-    '\u{0637}',
-    '\u{0638}',
-    '\u{0638}',
-    '\u{0638}',
-    '\u{0638}',
-    '\u{0639}',
-    '\u{0639}',
-    '\u{0639}',
-    '\u{0639}',
-    '\u{063A}',
-    '\u{063A}',
-    '\u{063A}',
-    '\u{063A}',
-    '\u{0641}',
-    '\u{0641}',
-    '\u{0641}',
-    '\u{0641}',
-    '\u{0642}',
-    '\u{0642}',
-    '\u{0642}',
-    '\u{0642}',
-    '\u{0643}',
-    '\u{0643}',
-    '\u{0643}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0644}',
-    '\u{0644}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0646}',
-    '\u{0646}',
-    '\u{0646}',
-    '\u{0647}',
-    '\u{0647}',
-    '\u{0647}',
-    '\u{0647}',
-    '\u{0648}',
-    '\u{0648}',
-    '\u{0649}',
-    '\u{0649}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0653}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0653}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0654}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0654}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0655}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0655}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0644}',
-    '\u{0627}',
-    '\u{0021}',
-    '\u{0022}',
-    '\u{0023}',
-    '\u{0024}',
-    '\u{0025}',
-    '\u{0026}',
-    '\u{0027}',
-    '\u{0028}',
-    '\u{0029}',
-    '\u{002A}',
-    '\u{002B}',
-    '\u{002C}',
-    '\u{002D}',
-    '\u{002E}',
-    '\u{002F}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{003A}',
-    '\u{003B}',
-    '\u{003C}',
-    '\u{003D}',
-    '\u{003E}',
-    '\u{003F}',
-    '\u{0040}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{005B}',
-    '\u{005C}',
-    '\u{005D}',
-    '\u{005E}',
-    '\u{005F}',
-    '\u{0060}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{007B}',
-    '\u{007C}',
-    '\u{007D}',
-    '\u{007E}',
-    '\u{2985}',
-    '\u{2986}',
-    '\u{3002}',
-    '\u{300C}',
-    '\u{300D}',
-    '\u{3001}',
-    '\u{30FB}',
-    '\u{30F2}',
-    '\u{30A1}',
-    '\u{30A3}',
-    '\u{30A5}',
-    '\u{30A7}',
-    '\u{30A9}',
-    '\u{30E3}',
-    '\u{30E5}',
-    '\u{30E7}',
-    '\u{30C3}',
-    '\u{30FC}',
-    '\u{30A2}',
-    '\u{30A4}',
-    '\u{30A6}',
-    '\u{30A8}',
-    '\u{30AA}',
-    '\u{30AB}',
-    '\u{30AD}',
-    '\u{30AF}',
-    '\u{30B1}',
-    '\u{30B3}',
-    '\u{30B5}',
-    '\u{30B7}',
-    '\u{30B9}',
-    '\u{30BB}',
-    '\u{30BD}',
-    '\u{30BF}',
-    '\u{30C1}',
-    '\u{30C4}',
-    '\u{30C6}',
-    '\u{30C8}',
-    '\u{30CA}',
-    '\u{30CB}',
-    '\u{30CC}',
-    '\u{30CD}',
-    '\u{30CE}',
-    '\u{30CF}',
-    '\u{30D2}',
-    '\u{30D5}',
-    '\u{30D8}',
-    '\u{30DB}',
-    '\u{30DE}',
-    '\u{30DF}',
-    '\u{30E0}',
-    '\u{30E1}',
-    '\u{30E2}',
-    '\u{30E4}',
-    '\u{30E6}',
-    '\u{30E8}',
-    '\u{30E9}',
-    '\u{30EA}',
-    '\u{30EB}',
-    '\u{30EC}',
-    '\u{30ED}',
-    '\u{30EF}',
-    '\u{30F3}',
-    '\u{3099}',
-    '\u{309A}',
-    '\u{1160}',
-    '\u{1100}',
-    '\u{1101}',
-    '\u{11AA}',
-    '\u{1102}',
-    '\u{11AC}',
-    '\u{11AD}',
-    '\u{1103}',
-    '\u{1104}',
-    '\u{1105}',
-    '\u{11B0}',
-    '\u{11B1}',
-    '\u{11B2}',
-    '\u{11B3}',
-    '\u{11B4}',
-    '\u{11B5}',
-    '\u{111A}',
-    '\u{1106}',
-    '\u{1107}',
-    '\u{1108}',
-    '\u{1121}',
-    '\u{1109}',
-    '\u{110A}',
-    '\u{110B}',
-    '\u{110C}',
-    '\u{110D}',
-    '\u{110E}',
-    '\u{110F}',
-    '\u{1110}',
-    '\u{1111}',
-    '\u{1112}',
-    '\u{1161}',
-    '\u{1162}',
-    '\u{1163}',
-    '\u{1164}',
-    '\u{1165}',
-    '\u{1166}',
-    '\u{1167}',
-    '\u{1168}',
-    '\u{1169}',
-    '\u{116A}',
-    '\u{116B}',
-    '\u{116C}',
-    '\u{116D}',
-    '\u{116E}',
-    '\u{116F}',
-    '\u{1170}',
-    '\u{1171}',
-    '\u{1172}',
-    '\u{1173}',
-    '\u{1174}',
-    '\u{1175}',
-    '\u{00A2}',
-    '\u{00A3}',
-    '\u{00AC}',
-    '\u{0020}',
-    '\u{0304}',
-    '\u{00A6}',
-    '\u{00A5}',
-    '\u{20A9}',
-    '\u{2502}',
-    '\u{2190}',
-    '\u{2191}',
-    '\u{2192}',
-    '\u{2193}',
-    '\u{25A0}',
-    '\u{25CB}',
-    '\u{02D0}',
-    '\u{02D1}',
-    '\u{00E6}',
-    '\u{0299}',
-    '\u{0253}',
-    '\u{02A3}',
-    '\u{AB66}',
-    '\u{02A5}',
-    '\u{02A4}',
-    '\u{0256}',
-    '\u{0257}',
-    '\u{1D91}',
-    '\u{0258}',
-    '\u{025E}',
-    '\u{02A9}',
-    '\u{0264}',
-    '\u{0262}',
-    '\u{0260}',
-    '\u{029B}',
-    '\u{0127}',
-    '\u{029C}',
-    '\u{0267}',
-    '\u{0284}',
-    '\u{02AA}',
-    '\u{02AB}',
-    '\u{026C}',
-    '\u{1DF04}',
-    '\u{A78E}',
-    '\u{026E}',
-    '\u{1DF05}',
-    '\u{028E}',
-    '\u{1DF06}',
-    '\u{00F8}',
-    '\u{0276}',
-    '\u{0277}',
-    '\u{0071}',
-    '\u{027A}',
-    '\u{1DF08}',
-    '\u{027D}',
-    '\u{027E}',
-    '\u{0280}',
-    '\u{02A8}',
-    '\u{02A6}',
-    '\u{AB67}',
-    '\u{02A7}',
-    '\u{0288}',
-    '\u{2C71}',
-    '\u{028F}',
-    '\u{02A1}',
-    '\u{02A2}',
-    '\u{0298}',
-    '\u{01C0}',
-    '\u{01C1}',
-    '\u{01C2}',
-    '\u{1DF0A}',
-    '\u{1DF1E}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0047}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0066}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004F}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0061}',
-    '\u{0062}',
-    '\u{0063}',
-    '\u{0064}',
-    '\u{0065}',
-    '\u{0066}',
-    '\u{0067}',
-    '\u{0068}',
-    '\u{0069}',
-    '\u{006A}',
-    '\u{006B}',
-    '\u{006C}',
-    '\u{006D}',
-    '\u{006E}',
-    '\u{006F}',
-    '\u{0070}',
-    '\u{0071}',
-    '\u{0072}',
-    '\u{0073}',
-    '\u{0074}',
-    '\u{0075}',
-    '\u{0076}',
-    '\u{0077}',
-    '\u{0078}',
-    '\u{0079}',
-    '\u{007A}',
-    '\u{0131}',
-    '\u{0237}',
-    '\u{0391}',
-    '\u{0392}',
-    '\u{0393}',
-    '\u{0394}',
-    '\u{0395}',
-    '\u{0396}',
-    '\u{0397}',
-    '\u{0398}',
-    '\u{0399}',
-    '\u{039A}',
-    '\u{039B}',
-    '\u{039C}',
-    '\u{039D}',
-    '\u{039E}',
-    '\u{039F}',
-    '\u{03A0}',
-    '\u{03A1}',
-    '\u{0398}',
-    '\u{03A3}',
-    '\u{03A4}',
-    '\u{03A5}',
-    '\u{03A6}',
-    '\u{03A7}',
-    '\u{03A8}',
-    '\u{03A9}',
-    '\u{2207}',
-    '\u{03B1}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03B4}',
-    '\u{03B5}',
-    '\u{03B6}',
-    '\u{03B7}',
-    '\u{03B8}',
-    '\u{03B9}',
-    '\u{03BA}',
-    '\u{03BB}',
-    '\u{03BC}',
-    '\u{03BD}',
-    '\u{03BE}',
-    '\u{03BF}',
-    '\u{03C0}',
-    '\u{03C1}',
-    '\u{03C2}',
-    '\u{03C3}',
-    '\u{03C4}',
-    '\u{03C5}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{03C8}',
-    '\u{03C9}',
-    '\u{2202}',
-    '\u{03B5}',
-    '\u{03B8}',
-    '\u{03BA}',
-    '\u{03C6}',
-    '\u{03C1}',
-    '\u{03C0}',
-    '\u{0391}',
-    '\u{0392}',
-    '\u{0393}',
-    '\u{0394}',
-    '\u{0395}',
-    '\u{0396}',
-    '\u{0397}',
-    '\u{0398}',
-    '\u{0399}',
-    '\u{039A}',
-    '\u{039B}',
-    '\u{039C}',
-    '\u{039D}',
-    '\u{039E}',
-    '\u{039F}',
-    '\u{03A0}',
-    '\u{03A1}',
-    '\u{0398}',
-    '\u{03A3}',
-    '\u{03A4}',
-    '\u{03A5}',
-    '\u{03A6}',
-    '\u{03A7}',
-    '\u{03A8}',
-    '\u{03A9}',
-    '\u{2207}',
-    '\u{03B1}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03B4}',
-    '\u{03B5}',
-    '\u{03B6}',
-    '\u{03B7}',
-    '\u{03B8}',
-    '\u{03B9}',
-    '\u{03BA}',
-    '\u{03BB}',
-    '\u{03BC}',
-    '\u{03BD}',
-    '\u{03BE}',
-    '\u{03BF}',
-    '\u{03C0}',
-    '\u{03C1}',
-    '\u{03C2}',
-    '\u{03C3}',
-    '\u{03C4}',
-    '\u{03C5}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{03C8}',
-    '\u{03C9}',
-    '\u{2202}',
-    '\u{03B5}',
-    '\u{03B8}',
-    '\u{03BA}',
-    '\u{03C6}',
-    '\u{03C1}',
-    '\u{03C0}',
-    '\u{0391}',
-    '\u{0392}',
-    '\u{0393}',
-    '\u{0394}',
-    '\u{0395}',
-    '\u{0396}',
-    '\u{0397}',
-    '\u{0398}',
-    '\u{0399}',
-    '\u{039A}',
-    '\u{039B}',
-    '\u{039C}',
-    '\u{039D}',
-    '\u{039E}',
-    '\u{039F}',
-    '\u{03A0}',
-    '\u{03A1}',
-    '\u{0398}',
-    '\u{03A3}',
-    '\u{03A4}',
-    '\u{03A5}',
-    '\u{03A6}',
-    '\u{03A7}',
-    '\u{03A8}',
-    '\u{03A9}',
-    '\u{2207}',
-    '\u{03B1}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03B4}',
-    '\u{03B5}',
-    '\u{03B6}',
-    '\u{03B7}',
-    '\u{03B8}',
-    '\u{03B9}',
-    '\u{03BA}',
-    '\u{03BB}',
-    '\u{03BC}',
-    '\u{03BD}',
-    '\u{03BE}',
-    '\u{03BF}',
-    '\u{03C0}',
-    '\u{03C1}',
-    '\u{03C2}',
-    '\u{03C3}',
-    '\u{03C4}',
-    '\u{03C5}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{03C8}',
-    '\u{03C9}',
-    '\u{2202}',
-    '\u{03B5}',
-    '\u{03B8}',
-    '\u{03BA}',
-    '\u{03C6}',
-    '\u{03C1}',
-    '\u{03C0}',
-    '\u{0391}',
-    '\u{0392}',
-    '\u{0393}',
-    '\u{0394}',
-    '\u{0395}',
-    '\u{0396}',
-    '\u{0397}',
-    '\u{0398}',
-    '\u{0399}',
-    '\u{039A}',
-    '\u{039B}',
-    '\u{039C}',
-    '\u{039D}',
-    '\u{039E}',
-    '\u{039F}',
-    '\u{03A0}',
-    '\u{03A1}',
-    '\u{0398}',
-    '\u{03A3}',
-    '\u{03A4}',
-    '\u{03A5}',
-    '\u{03A6}',
-    '\u{03A7}',
-    '\u{03A8}',
-    '\u{03A9}',
-    '\u{2207}',
-    '\u{03B1}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03B4}',
-    '\u{03B5}',
-    '\u{03B6}',
-    '\u{03B7}',
-    '\u{03B8}',
-    '\u{03B9}',
-    '\u{03BA}',
-    '\u{03BB}',
-    '\u{03BC}',
-    '\u{03BD}',
-    '\u{03BE}',
-    '\u{03BF}',
-    '\u{03C0}',
-    '\u{03C1}',
-    '\u{03C2}',
-    '\u{03C3}',
-    '\u{03C4}',
-    '\u{03C5}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{03C8}',
-    '\u{03C9}',
-    '\u{2202}',
-    '\u{03B5}',
-    '\u{03B8}',
-    '\u{03BA}',
-    '\u{03C6}',
-    '\u{03C1}',
-    '\u{03C0}',
-    '\u{0391}',
-    '\u{0392}',
-    '\u{0393}',
-    '\u{0394}',
-    '\u{0395}',
-    '\u{0396}',
-    '\u{0397}',
-    '\u{0398}',
-    '\u{0399}',
-    '\u{039A}',
-    '\u{039B}',
-    '\u{039C}',
-    '\u{039D}',
-    '\u{039E}',
-    '\u{039F}',
-    '\u{03A0}',
-    '\u{03A1}',
-    '\u{0398}',
-    '\u{03A3}',
-    '\u{03A4}',
-    '\u{03A5}',
-    '\u{03A6}',
-    '\u{03A7}',
-    '\u{03A8}',
-    '\u{03A9}',
-    '\u{2207}',
-    '\u{03B1}',
-    '\u{03B2}',
-    '\u{03B3}',
-    '\u{03B4}',
-    '\u{03B5}',
-    '\u{03B6}',
-    '\u{03B7}',
-    '\u{03B8}',
-    '\u{03B9}',
-    '\u{03BA}',
-    '\u{03BB}',
-    '\u{03BC}',
-    '\u{03BD}',
-    '\u{03BE}',
-    '\u{03BF}',
-    '\u{03C0}',
-    '\u{03C1}',
-    '\u{03C2}',
-    '\u{03C3}',
-    '\u{03C4}',
-    '\u{03C5}',
-    '\u{03C6}',
-    '\u{03C7}',
-    '\u{03C8}',
-    '\u{03C9}',
-    '\u{2202}',
-    '\u{03B5}',
-    '\u{03B8}',
-    '\u{03BA}',
-    '\u{03C6}',
-    '\u{03C1}',
-    '\u{03C0}',
-    '\u{03DC}',
-    '\u{03DD}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-    '\u{0430}',
-    '\u{0431}',
-    '\u{0432}',
-    '\u{0433}',
-    '\u{0434}',
-    '\u{0435}',
-    '\u{0436}',
-    '\u{0437}',
-    '\u{0438}',
-    '\u{043A}',
-    '\u{043B}',
-    '\u{043C}',
-    '\u{043E}',
-    '\u{043F}',
-    '\u{0440}',
-    '\u{0441}',
-    '\u{0442}',
-    '\u{0443}',
-    '\u{0444}',
-    '\u{0445}',
-    '\u{0446}',
-    '\u{0447}',
-    '\u{0448}',
-    '\u{044B}',
-    '\u{044D}',
-    '\u{044E}',
-    '\u{A689}',
-    '\u{04D9}',
-    '\u{0456}',
-    '\u{0458}',
-    '\u{04E9}',
-    '\u{04AF}',
-    '\u{04CF}',
-    '\u{0430}',
-    '\u{0431}',
-    '\u{0432}',
-    '\u{0433}',
-    '\u{0434}',
-    '\u{0435}',
-    '\u{0436}',
-    '\u{0437}',
-    '\u{0438}',
-    '\u{043A}',
-    '\u{043B}',
-    '\u{043E}',
-    '\u{043F}',
-    '\u{0441}',
-    '\u{0443}',
-    '\u{0444}',
-    '\u{0445}',
-    '\u{0446}',
-    '\u{0447}',
-    '\u{0448}',
-    '\u{044A}',
-    '\u{044B}',
-    '\u{0491}',
-    '\u{0456}',
-    '\u{0455}',
-    '\u{045F}',
-    '\u{04AB}',
-    '\u{A651}',
-    '\u{04B1}',
-    '\u{0627}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{062F}',
-    '\u{0648}',
-    '\u{0632}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0633}',
-    '\u{0639}',
-    '\u{0641}',
-    '\u{0635}',
-    '\u{0642}',
-    '\u{0631}',
-    '\u{0634}',
-    '\u{062A}',
-    '\u{062B}',
-    '\u{062E}',
-    '\u{0630}',
-    '\u{0636}',
-    '\u{0638}',
-    '\u{063A}',
-    '\u{066E}',
-    '\u{06BA}',
-    '\u{06A1}',
-    '\u{066F}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{0647}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0633}',
-    '\u{0639}',
-    '\u{0641}',
-    '\u{0635}',
-    '\u{0642}',
-    '\u{0634}',
-    '\u{062A}',
-    '\u{062B}',
-    '\u{062E}',
-    '\u{0636}',
-    '\u{063A}',
-    '\u{062C}',
-    '\u{062D}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{0646}',
-    '\u{0633}',
-    '\u{0639}',
-    '\u{0635}',
-    '\u{0642}',
-    '\u{0634}',
-    '\u{062E}',
-    '\u{0636}',
-    '\u{063A}',
-    '\u{06BA}',
-    '\u{066F}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{0647}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{064A}',
-    '\u{0643}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0633}',
-    '\u{0639}',
-    '\u{0641}',
-    '\u{0635}',
-    '\u{0642}',
-    '\u{0634}',
-    '\u{062A}',
-    '\u{062B}',
-    '\u{062E}',
-    '\u{0636}',
-    '\u{0638}',
-    '\u{063A}',
-    '\u{066E}',
-    '\u{06A1}',
-    '\u{0627}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{062F}',
-    '\u{0647}',
-    '\u{0648}',
-    '\u{0632}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0633}',
-    '\u{0639}',
-    '\u{0641}',
-    '\u{0635}',
-    '\u{0642}',
-    '\u{0631}',
-    '\u{0634}',
-    '\u{062A}',
-    '\u{062B}',
-    '\u{062E}',
-    '\u{0630}',
-    '\u{0636}',
-    '\u{0638}',
-    '\u{063A}',
-    '\u{0628}',
-    '\u{062C}',
-    '\u{062F}',
-    '\u{0648}',
-    '\u{0632}',
-    '\u{062D}',
-    '\u{0637}',
-    '\u{064A}',
-    '\u{0644}',
-    '\u{0645}',
-    '\u{0646}',
-    '\u{0633}',
-    '\u{0639}',
-    '\u{0641}',
-    '\u{0635}',
-    '\u{0642}',
-    '\u{0631}',
-    '\u{0634}',
-    '\u{062A}',
-    '\u{062B}',
-    '\u{062E}',
-    '\u{0630}',
-    '\u{0636}',
-    '\u{0638}',
-    '\u{063A}',
-    '\u{0030}',
-    '\u{002E}',
-    '\u{0030}',
-    '\u{002C}',
-    '\u{0031}',
-    '\u{002C}',
-    '\u{0032}',
-    '\u{002C}',
-    '\u{0033}',
-    '\u{002C}',
-    '\u{0034}',
-    '\u{002C}',
-    '\u{0035}',
-    '\u{002C}',
-    '\u{0036}',
-    '\u{002C}',
-    '\u{0037}',
-    '\u{002C}',
-    '\u{0038}',
-    '\u{002C}',
-    '\u{0039}',
-    '\u{002C}',
-    '\u{0028}',
-    '\u{0041}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0042}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0043}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0044}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0045}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0046}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0047}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0048}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0049}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{004A}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{004B}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{004C}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{004D}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{004E}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{004F}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0050}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0051}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0052}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0053}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0054}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0055}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0056}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0057}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0058}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{0059}',
-    '\u{0029}',
-    '\u{0028}',
-    '\u{005A}',
-    '\u{0029}',
-    '\u{3014}',
-    '\u{0053}',
-    '\u{3015}',
-    '\u{0043}',
-    '\u{0052}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0057}',
-    '\u{005A}',
-    '\u{0041}',
-    '\u{0042}',
-    '\u{0043}',
-    '\u{0044}',
-    '\u{0045}',
-    '\u{0046}',
-    '\u{0047}',
-    '\u{0048}',
-    '\u{0049}',
-    '\u{004A}',
-    '\u{004B}',
-    '\u{004C}',
-    '\u{004D}',
-    '\u{004E}',
-    '\u{004F}',
-    '\u{0050}',
-    '\u{0051}',
-    '\u{0052}',
-    '\u{0053}',
-    '\u{0054}',
-    '\u{0055}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0058}',
-    '\u{0059}',
-    '\u{005A}',
-    '\u{0048}',
-    '\u{0056}',
-    '\u{004D}',
-    '\u{0056}',
-    '\u{0053}',
-    '\u{0044}',
-    '\u{0053}',
-    '\u{0053}',
-    '\u{0050}',
-    '\u{0050}',
-    '\u{0056}',
-    '\u{0057}',
-    '\u{0043}',
-    '\u{004D}',
-    '\u{0043}',
-    '\u{004D}',
-    '\u{0044}',
-    '\u{004D}',
-    '\u{0052}',
-    '\u{0044}',
-    '\u{004A}',
-    '\u{307B}',
-    '\u{304B}',
-    '\u{30B3}',
-    '\u{30B3}',
-    '\u{30B5}',
-    '\u{624B}',
-    '\u{5B57}',
-    '\u{53CC}',
-    '\u{30C6}',
-    '\u{3099}',
-    '\u{4E8C}',
-    '\u{591A}',
-    '\u{89E3}',
-    '\u{5929}',
-    '\u{4EA4}',
-    '\u{6620}',
-    '\u{7121}',
-    '\u{6599}',
-    '\u{524D}',
-    '\u{5F8C}',
-    '\u{518D}',
-    '\u{65B0}',
-    '\u{521D}',
-    '\u{7D42}',
-    '\u{751F}',
-    '\u{8CA9}',
-    '\u{58F0}',
-    '\u{5439}',
-    '\u{6F14}',
-    '\u{6295}',
-    '\u{6355}',
-    '\u{4E00}',
-    '\u{4E09}',
-    '\u{904A}',
-    '\u{5DE6}',
-    '\u{4E2D}',
-    '\u{53F3}',
-    '\u{6307}',
-    '\u{8D70}',
-    '\u{6253}',
-    '\u{7981}',
-    '\u{7A7A}',
-    '\u{5408}',
-    '\u{6E80}',
-    '\u{6709}',
-    '\u{6708}',
-    '\u{7533}',
-    '\u{5272}',
-    '\u{55B6}',
-    '\u{914D}',
-    '\u{3014}',
-    '\u{672C}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{4E09}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{4E8C}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{5B89}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{70B9}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{6253}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{76D7}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{52DD}',
-    '\u{3015}',
-    '\u{3014}',
-    '\u{6557}',
-    '\u{3015}',
-    '\u{5F97}',
-    '\u{53EF}',
-    '\u{0030}',
-    '\u{0031}',
-    '\u{0032}',
-    '\u{0033}',
-    '\u{0034}',
-    '\u{0035}',
-    '\u{0036}',
-    '\u{0037}',
-    '\u{0038}',
-    '\u{0039}',
-];
-
-pub(crate) const COMPATIBILITY_DECOMPOSED_SALT: &[u16] = &[
-    0x000, 0x000, 0x00A, 0x000, 0x000, 0x000, 0x001, 0x1B9F, 0x004, 0xF3F, 0x005, 0x185, 0x000,
-    0x000, 0x001, 0x000, 0x001, 0x002, 0x19D, 0x000, 0x099, 0x000, 0x03E, 0x000, 0x00A, 0x3FC,
-    0x0A1, 0x000, 0x000, 0x000, 0x000, 0x001, 0x1EA, 0x000, 0x59B, 0x001, 0x3D6, 0x000, 0x078,
-    0x000, 0x2F7, 0x017, 0x00E, 0x0BA, 0x0B8, 0x000, 0x0A3, 0x089, 0x007, 0x014, 0x000, 0x000,
-    0x000, 0x003, 0x000, 0x000, 0x000, 0x243, 0x047, 0x005, 0x000, 0x000, 0x13F, 0x009, 0x001,
-    0x000, 0x000, 0x004, 0x015, 0x001, 0x0D6, 0x01C, 0x000, 0x002, 0x0FF, 0x1B5, 0x000, 0x000,
-    0x002, 0x001, 0x006, 0x000, 0x0EC, 0x004, 0x038, 0x0F3, 0x000, 0x00A, 0x01A, 0x001, 0x000,
-    0x0A1, 0x000, 0x000, 0x013, 0x0CC, 0x05C, 0x007, 0x000, 0x052, 0x000, 0x00D, 0x000, 0x000,
-    0x043, 0x001, 0x004, 0x003, 0x05D, 0x11C, 0x004, 0x001, 0x000, 0x000, 0x053, 0x008, 0x000,
-    0x000, 0x002, 0x000, 0x01E, 0x04D, 0x000, 0x022, 0x001, 0x01F, 0x000, 0x001, 0x000, 0x000,
-    0x000, 0x01E, 0x022, 0x013, 0x007, 0x004, 0x000, 0x060, 0x005, 0x000, 0x000, 0x000, 0x004,
-    0x06A, 0x000, 0x000, 0x000, 0x088, 0x001, 0x000, 0x07F, 0x000, 0x002, 0x000, 0x000, 0x00D,
-    0x038, 0x0A7, 0x049, 0x0D5, 0x001, 0x028, 0x004, 0x002, 0x000, 0x030, 0x00A, 0x001, 0x0F0,
-    0x024, 0x002, 0x031, 0x09B, 0x000, 0x090, 0x003, 0x00B, 0x003, 0x002, 0x000, 0x057, 0x000,
-    0x004, 0x000, 0x000, 0x000, 0x000, 0x005, 0x000, 0x03A, 0x006, 0x00E, 0x007, 0x000, 0x089,
-    0x000, 0x000, 0x001, 0x005, 0x006, 0x02F, 0x000, 0x068, 0x001, 0x000, 0x043, 0x000, 0x028,
-    0x000, 0x000, 0x0A4, 0x035, 0x013, 0x01F, 0x02F, 0x002, 0x011, 0x052, 0x008, 0x000, 0x000,
-    0x013, 0x014, 0x000, 0x024, 0x000, 0x000, 0x001, 0x02C, 0x001, 0x000, 0x000, 0x014, 0x00C,
-    0x016, 0x000, 0x000, 0x008, 0x00A, 0x006, 0x000, 0x000, 0x00D, 0x000, 0x0A9, 0x000, 0x000,
-    0x000, 0x000, 0x009, 0x000, 0x000, 0x001, 0x000, 0x000, 0x002, 0x012, 0x000, 0x000, 0x036,
-    0x002, 0x01E, 0x004, 0x00C, 0x000, 0x002, 0x000, 0x012, 0x001, 0x035, 0x000, 0x000, 0x00A,
-    0x007, 0x015, 0x005, 0x01C, 0x024, 0x07A, 0x000, 0x005, 0x001, 0x012, 0x000, 0x004, 0x001,
-    0x005, 0x010, 0x009, 0x000, 0x020, 0x01B, 0x006, 0x01E, 0x005, 0x04A, 0x000, 0x004, 0x000,
-    0x014, 0x000, 0x009, 0x065, 0x000, 0x001, 0x000, 0x074, 0x000, 0x000, 0x045, 0x001, 0x000,
-    0x000, 0x008, 0x000, 0x000, 0x017, 0x000, 0x000, 0x006, 0x000, 0x002, 0x000, 0x005, 0x000,
-    0x01B, 0x000, 0x017, 0x000, 0x001, 0x003, 0x029, 0x002, 0x002, 0x007, 0x007, 0x001, 0x001,
-    0x03A, 0x001, 0x001, 0x000, 0x003, 0x000, 0x004, 0x001, 0x011, 0x016, 0x000, 0x002, 0x000,
-    0x002, 0x002, 0x002, 0x006, 0x000, 0x046, 0x000, 0x002, 0x000, 0x000, 0x00D, 0x011, 0x000,
-    0x000, 0x01B, 0x03D, 0x007, 0x024, 0x019, 0x008, 0x05C, 0x000, 0x028, 0x004, 0x014, 0x002,
-    0x004, 0x001, 0x001, 0x001, 0x000, 0x008, 0x008, 0x012, 0x002, 0x052, 0x00F, 0x000, 0x000,
-    0x000, 0x007, 0x006, 0x000, 0x01E, 0x01D, 0x001, 0x010, 0x000, 0x000, 0x000, 0x001, 0x001,
-    0x000, 0x004, 0x006, 0x017, 0x006, 0x004, 0x003, 0x003, 0x03E, 0x000, 0x002, 0x007, 0x023,
-    0x000, 0x000, 0x001, 0x000, 0x000, 0x004, 0x007, 0x021, 0x010, 0x019, 0x005, 0x000, 0x007,
-    0x000, 0x001, 0x000, 0x000, 0x000, 0x00C, 0x012, 0x02E, 0x000, 0x013, 0x027, 0x000, 0x013,
-    0x000, 0x000, 0x006, 0x02C, 0x000, 0x006, 0x000, 0x00E, 0x001, 0x001, 0x005, 0x002, 0x004,
-    0x016, 0x00D, 0x012, 0x008, 0x000, 0x001, 0x003, 0x000, 0x000, 0x001, 0x000, 0x000, 0x010,
-    0x000, 0x000, 0x00B, 0x000, 0x000, 0x007, 0x004, 0x00F, 0x008, 0x001, 0x006, 0x001, 0x004,
-    0x004, 0x00A, 0x002, 0x000, 0x002, 0x003, 0x005, 0x000, 0x000, 0x00B, 0x00B, 0x000, 0x005,
-    0x003, 0x000, 0x000, 0x004, 0x004, 0x01C, 0x020, 0x000, 0x000, 0x000, 0x000, 0x013, 0x00D,
-    0x00A, 0x003, 0x000, 0x00C, 0x00B, 0x000, 0x001, 0x000, 0x000, 0x003, 0x001, 0x001, 0x03E,
-    0x000, 0x001, 0x017, 0x000, 0x019, 0x010, 0x003, 0x000, 0x000, 0x000, 0x000, 0x003, 0x000,
-    0x008, 0x001, 0x000, 0x007, 0x003, 0x010, 0x001, 0x000, 0x002, 0x009, 0x000, 0x08B, 0x000,
-    0x005, 0x000, 0x008, 0x000, 0x005, 0x012, 0x00F, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x001, 0x046, 0x000, 0x004, 0x00C, 0x000, 0x001, 0x006, 0x000, 0x014, 0x005, 0x01A, 0x007,
-    0x000, 0x002, 0x005, 0x000, 0x007, 0x001, 0x020, 0x00D, 0x00B, 0x02B, 0x000, 0x01B, 0x000,
-    0x003, 0x000, 0x001, 0x01A, 0x001, 0x004, 0x000, 0x000, 0x007, 0x000, 0x00C, 0x01B, 0x023,
-    0x002, 0x000, 0x019, 0x01F, 0x001, 0x010, 0x008, 0x00A, 0x000, 0x000, 0x006, 0x002, 0x002,
-    0x002, 0x012, 0x009, 0x01E, 0x004, 0x000, 0x00B, 0x004, 0x008, 0x01E, 0x003, 0x006, 0x00C,
-    0x000, 0x000, 0x002, 0x000, 0x00A, 0x000, 0x01B, 0x000, 0x001, 0x009, 0x000, 0x00F, 0x002,
-    0x000, 0x00A, 0x000, 0x008, 0x000, 0x001, 0x000, 0x000, 0x001, 0x001, 0x00C, 0x00C, 0x001,
-    0x000, 0x000, 0x004, 0x000, 0x005, 0x000, 0x022, 0x002, 0x00F, 0x015, 0x00D, 0x000, 0x000,
-    0x001, 0x000, 0x016, 0x000, 0x000, 0x000, 0x000, 0x008, 0x000, 0x000, 0x001, 0x000, 0x000,
-    0x004, 0x001, 0x001, 0x004, 0x002, 0x002, 0x00F, 0x00A, 0x014, 0x000, 0x000, 0x001, 0x002,
-    0x000, 0x002, 0x00F, 0x000, 0x000, 0x007, 0x000, 0x026, 0x000, 0x035, 0x009, 0x000, 0x005,
-    0x002, 0x000, 0x00F, 0x003, 0x003, 0x006, 0x000, 0x02F, 0x002, 0x000, 0x007, 0x000, 0x000,
-    0x001, 0x008, 0x016, 0x003, 0x000, 0x000, 0x016, 0x000, 0x002, 0x000, 0x00D, 0x000, 0x001,
-    0x000, 0x005, 0x001, 0x00A, 0x000, 0x000, 0x002, 0x00A, 0x001, 0x000, 0x000, 0x006, 0x001,
-    0x000, 0x003, 0x002, 0x015, 0x000, 0x002, 0x000, 0x000, 0x003, 0x001, 0x008, 0x002, 0x000,
-    0x006, 0x000, 0x001, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x00D, 0x014, 0x000, 0x001,
-    0x000, 0x004, 0x000, 0x003, 0x002, 0x000, 0x000, 0x004, 0x019, 0x006, 0x007, 0x013, 0x019,
-    0x003, 0x00B, 0x008, 0x013, 0x007, 0x002, 0x009, 0x000, 0x000, 0x019, 0x016, 0x002, 0x015,
-    0x000, 0x004, 0x000, 0x007, 0x000, 0x008, 0x000, 0x000, 0x007, 0x001, 0x006, 0x01E, 0x01B,
-    0x000, 0x00C, 0x003, 0x00F, 0x000, 0x000, 0x001, 0x00A, 0x000, 0x000, 0x000, 0x006, 0x016,
-    0x006, 0x002, 0x000, 0x015, 0x006, 0x004, 0x002, 0x009, 0x000, 0x009, 0x002, 0x000, 0x00A,
-    0x000, 0x000, 0x005, 0x00C, 0x000, 0x005, 0x001, 0x004, 0x000, 0x00A, 0x001, 0x004, 0x008,
-    0x00E, 0x000, 0x001, 0x002, 0x006, 0x001, 0x000, 0x024, 0x000, 0x000, 0x003, 0x001, 0x000,
-    0x004, 0x002, 0x000, 0x016, 0x001, 0x009, 0x000, 0x007, 0x000, 0x017, 0x001, 0x000, 0x005,
-    0x016, 0x002, 0x01F, 0x000, 0x000, 0x002, 0x000, 0x000, 0x00A, 0x001, 0x00A, 0x000, 0x007,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x005, 0x000, 0x005, 0x00B, 0x00C, 0x000, 0x000,
-    0x001, 0x004, 0x006, 0x003, 0x001, 0x016, 0x001, 0x000, 0x000, 0x001, 0x004, 0x000, 0x001,
-    0x019, 0x003, 0x003, 0x004, 0x005, 0x001, 0x01D, 0x000, 0x000, 0x007, 0x001, 0x001, 0x01F,
-    0x000, 0x000, 0x001, 0x02B, 0x006, 0x010, 0x000, 0x009, 0x006, 0x00C, 0x00A, 0x002, 0x000,
-    0x000, 0x001, 0x00C, 0x000, 0x000, 0x000, 0x016, 0x000, 0x000, 0x016, 0x00C, 0x00F, 0x000,
-    0x010, 0x002, 0x000, 0x00C, 0x01C, 0x002, 0x000, 0x000, 0x000, 0x000, 0x001, 0x002, 0x000,
-    0x003, 0x017, 0x004, 0x01C, 0x005, 0x00C, 0x001, 0x007, 0x004, 0x000, 0x001, 0x002, 0x000,
-    0x00E, 0x00F, 0x002, 0x009, 0x001, 0x006, 0x020, 0x00B, 0x000, 0x000, 0x001, 0x00B, 0x002,
-    0x002, 0x000, 0x000, 0x000, 0x007, 0x000, 0x001, 0x000, 0x000, 0x001, 0x001, 0x000, 0x007,
-    0x000, 0x003, 0x006, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000, 0x00B, 0x002, 0x000, 0x006,
-    0x001, 0x001, 0x000, 0x00E, 0x00C, 0x000, 0x006, 0x000, 0x000, 0x00E, 0x000, 0x003, 0x001,
-    0x000, 0x000, 0x023, 0x009, 0x007, 0x000, 0x000, 0x011, 0x012, 0x000, 0x000, 0x006, 0x001,
-    0x001, 0x000, 0x00D, 0x008, 0x007, 0x002, 0x029, 0x003, 0x008, 0x004, 0x002, 0x00C, 0x001,
-    0x000, 0x001, 0x00E, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x002, 0x000, 0x007,
-    0x005, 0x004, 0x000, 0x000, 0x002, 0x005, 0x005, 0x005, 0x001, 0x007, 0x002, 0x00C, 0x000,
-    0x003, 0x008, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x006, 0x003, 0x008,
-    0x000, 0x000, 0x006, 0x003, 0x004, 0x015, 0x000, 0x007, 0x005, 0x004, 0x000, 0x008, 0x000,
-    0x006, 0x000, 0x006, 0x004, 0x002, 0x000, 0x00F, 0x001, 0x000, 0x000, 0x000, 0x002, 0x007,
-    0x000, 0x01A, 0x008, 0x000, 0x000, 0x001, 0x003, 0x000, 0x00C, 0x000, 0x000, 0x001, 0x005,
-    0x00C, 0x000, 0x000, 0x004, 0x002, 0x000, 0x003, 0x006, 0x001, 0x004, 0x00A, 0x000, 0x002,
-    0x000, 0x000, 0x005, 0x007, 0x001, 0x013, 0x01A, 0x001, 0x003, 0x000, 0x003, 0x000, 0x000,
-    0x006, 0x010, 0x000, 0x002, 0x019, 0x00B, 0x001, 0x00E, 0x000, 0x006, 0x016, 0x014, 0x000,
-    0x000, 0x000, 0x004, 0x000, 0x000, 0x005, 0x002, 0x00B, 0x002, 0x016, 0x000, 0x000, 0x003,
-    0x001, 0x000, 0x001, 0x000, 0x00C, 0x002, 0x014, 0x000, 0x000, 0x004, 0x003, 0x009, 0x009,
-    0x000, 0x001, 0x000, 0x000, 0x002, 0x001, 0x001, 0x000, 0x001, 0x000, 0x001, 0x007, 0x005,
-    0x005, 0x000, 0x000, 0x001, 0x003, 0x003, 0x002, 0x011, 0x01C, 0x002, 0x011, 0x003, 0x000,
-    0x00D, 0x002, 0x001, 0x001, 0x030, 0x00B, 0x007, 0x000, 0x000, 0x01C, 0x001, 0x001, 0x003,
-    0x002, 0x000, 0x001, 0x00D, 0x000, 0x009, 0x000, 0x001, 0x001, 0x006, 0x006, 0x002, 0x000,
-    0x001, 0x003, 0x00D, 0x004, 0x003, 0x011, 0x005, 0x000, 0x009, 0x000, 0x000, 0x000, 0x002,
-    0x002, 0x014, 0x000, 0x000, 0x000, 0x001, 0x004, 0x001, 0x000, 0x001, 0x003, 0x000, 0x000,
-    0x002, 0x000, 0x009, 0x003, 0x000, 0x000, 0x000, 0x002, 0x000, 0x007, 0x003, 0x001, 0x000,
-    0x003, 0x005, 0x010, 0x001, 0x000, 0x013, 0x000, 0x003, 0x005, 0x000, 0x002, 0x000, 0x000,
-    0x001, 0x001, 0x001, 0x001, 0x003, 0x004, 0x003, 0x001, 0x00D, 0x000, 0x001, 0x002, 0x000,
-    0x008, 0x007, 0x001, 0x003, 0x000, 0x000, 0x000, 0x00E, 0x004, 0x000, 0x006, 0x00D, 0x000,
-    0x000, 0x000, 0x003, 0x000, 0x000, 0x003, 0x000, 0x000, 0x020, 0x00A, 0x000, 0x001, 0x002,
-    0x000, 0x000, 0x000, 0x007, 0x008, 0x000, 0x008, 0x01F, 0x001, 0x000, 0x013, 0x008, 0x001,
-    0x00A, 0x005, 0x004, 0x008, 0x001, 0x001, 0x000, 0x001, 0x004, 0x003, 0x006, 0x002, 0x001,
-    0x000, 0x000, 0x000, 0x005, 0x000, 0x001, 0x000, 0x000, 0x000, 0x004, 0x000, 0x000, 0x00C,
-    0x002, 0x007, 0x000, 0x000, 0x00C, 0x003, 0x000, 0x000, 0x009, 0x002, 0x001, 0x004, 0x000,
-    0x000, 0x000, 0x000, 0x008, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x009, 0x007, 0x00F,
-    0x001, 0x024, 0x00C, 0x002, 0x001, 0x000, 0x000, 0x000, 0x008, 0x001, 0x009, 0x00B, 0x000,
-    0x00F, 0x002, 0x001, 0x000, 0x000, 0x000, 0x01C, 0x002, 0x001, 0x001, 0x003, 0x001, 0x001,
-    0x000, 0x000, 0x005, 0x001, 0x000, 0x000, 0x000, 0x001, 0x006, 0x009, 0x002, 0x007, 0x005,
-    0x00C, 0x002, 0x001, 0x006, 0x003, 0x002, 0x003, 0x002, 0x004, 0x003, 0x003, 0x007, 0x000,
-    0x001, 0x004, 0x00A, 0x000, 0x001, 0x004, 0x001, 0x002, 0x000, 0x000, 0x000, 0x000, 0x003,
-    0x003, 0x001, 0x001, 0x008, 0x035, 0x000, 0x003, 0x002, 0x000, 0x002, 0x001, 0x000, 0x001,
-    0x001, 0x002, 0x000, 0x00B, 0x002, 0x001, 0x000, 0x000, 0x006, 0x000, 0x004, 0x007, 0x001,
-    0x004, 0x004, 0x002, 0x000, 0x000, 0x003, 0x002, 0x001, 0x000, 0x000, 0x00C, 0x002, 0x00B,
-    0x001, 0x00C, 0x000, 0x000, 0x001, 0x000, 0x003, 0x014, 0x001, 0x003, 0x001, 0x001, 0x009,
-    0x000, 0x005, 0x003, 0x00A, 0x000, 0x001, 0x009, 0x007, 0x000, 0x005, 0x000, 0x003, 0x002,
-    0x000, 0x000, 0x00C, 0x00C, 0x00C, 0x00E, 0x000, 0x004, 0x001, 0x000, 0x002, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x001, 0x000, 0x001, 0x003, 0x004, 0x001,
-    0x002, 0x002, 0x000, 0x005, 0x000, 0x005, 0x00C, 0x000, 0x000, 0x004, 0x001, 0x000, 0x000,
-    0x034, 0x007, 0x003, 0x00A, 0x000, 0x000, 0x000, 0x002, 0x004, 0x005, 0x000, 0x002, 0x008,
-    0x000, 0x000, 0x000, 0x006, 0x001, 0x000, 0x003, 0x000, 0x008, 0x010, 0x000, 0x004, 0x000,
-    0x000, 0x000, 0x004, 0x000, 0x002, 0x002, 0x000, 0x003, 0x003, 0x001, 0x004, 0x000, 0x005,
-    0x011, 0x001, 0x001, 0x002, 0x00C, 0x009, 0x00A, 0x000, 0x002, 0x004, 0x001, 0x021, 0x000,
-    0x000, 0x000, 0x001, 0x005, 0x000, 0x006, 0x000, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x001, 0x00C, 0x000, 0x001, 0x001, 0x000, 0x000, 0x007, 0x000, 0x000, 0x000, 0x002, 0x001,
-    0x000, 0x001, 0x001, 0x002, 0x000, 0x008, 0x009, 0x005, 0x001, 0x003, 0x005, 0x002, 0x000,
-    0x004, 0x002, 0x000, 0x000, 0x001, 0x002, 0x006, 0x007, 0x006, 0x003, 0x009, 0x000, 0x006,
-    0x000, 0x006, 0x006, 0x007, 0x004, 0x000, 0x022, 0x002, 0x002, 0x002, 0x002, 0x008, 0x004,
-    0x000, 0x004, 0x000, 0x009, 0x003, 0x001, 0x00A, 0x005, 0x002, 0x000, 0x000, 0x002, 0x007,
-    0x001, 0x001, 0x006, 0x000, 0x001, 0x003, 0x000, 0x002, 0x001, 0x000, 0x005, 0x007, 0x001,
-    0x027, 0x002, 0x008, 0x000, 0x001, 0x002, 0x003, 0x000, 0x000, 0x002, 0x001, 0x009, 0x002,
-    0x001, 0x000, 0x002, 0x001, 0x011, 0x009, 0x000, 0x002, 0x001, 0x000, 0x00C, 0x007, 0x003,
-    0x004, 0x007, 0x001, 0x00C, 0x001, 0x009, 0x000, 0x005, 0x002, 0x000, 0x009, 0x001, 0x001,
-    0x003, 0x000, 0x007, 0x000, 0x00F, 0x000, 0x000, 0x000, 0x002, 0x002, 0x009, 0x000, 0x00A,
-    0x002, 0x000, 0x000, 0x007, 0x005, 0x000, 0x001, 0x000, 0x005, 0x000, 0x009, 0x000, 0x001,
-    0x002, 0x000, 0x000, 0x005, 0x009, 0x004, 0x003, 0x004, 0x000, 0x002, 0x001, 0x004, 0x001,
-    0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x000, 0x009, 0x007, 0x000, 0x001, 0x005, 0x009,
-    0x002, 0x00F, 0x001, 0x003, 0x001, 0x000, 0x000, 0x003, 0x000, 0x002, 0x000, 0x003, 0x005,
-    0x000, 0x002, 0x000, 0x004, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x001, 0x007, 0x000,
-    0x002, 0x000, 0x002, 0x008, 0x000, 0x000, 0x009, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x002, 0x001, 0x002, 0x006, 0x000, 0x000, 0x00F, 0x000, 0x001, 0x007, 0x000, 0x001, 0x000,
-    0x00D, 0x000, 0x002, 0x006, 0x000, 0x003, 0x003, 0x001, 0x007, 0x00D, 0x006, 0x004, 0x001,
-    0x001, 0x000, 0x001, 0x000, 0x001, 0x005, 0x002, 0x000, 0x000, 0x000, 0x018, 0x002, 0x002,
-    0x000, 0x000, 0x007, 0x000, 0x000, 0x003, 0x001, 0x008, 0x010, 0x003, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x004, 0x007, 0x000, 0x001, 0x000, 0x002, 0x004, 0x000, 0x008, 0x000, 0x000,
-    0x000, 0x00B, 0x000, 0x001, 0x000, 0x008, 0x00A, 0x001, 0x005, 0x001, 0x000, 0x007, 0x006,
-    0x000, 0x001, 0x000, 0x000, 0x001, 0x004, 0x000, 0x00B, 0x004, 0x003, 0x000, 0x000, 0x00C,
-    0x001, 0x000, 0x003, 0x008, 0x000, 0x001, 0x001, 0x000, 0x003, 0x00B, 0x006, 0x000, 0x001,
-    0x002, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x009, 0x003, 0x006,
-    0x000, 0x003, 0x003, 0x001, 0x001, 0x001, 0x000, 0x000, 0x005, 0x000, 0x000, 0x007, 0x003,
-    0x008, 0x002, 0x004, 0x000, 0x004, 0x006, 0x001, 0x002, 0x001, 0x002, 0x003, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x002, 0x001, 0x000, 0x002, 0x000, 0x007, 0x003, 0x00A, 0x003,
-    0x001, 0x004, 0x001, 0x004, 0x002, 0x006, 0x003, 0x002, 0x000, 0x000, 0x008, 0x011, 0x000,
-    0x000, 0x00D, 0x000, 0x000, 0x000, 0x000, 0x000, 0x006, 0x005, 0x000, 0x001, 0x000, 0x000,
-    0x001, 0x004, 0x000, 0x000, 0x004, 0x001, 0x001, 0x000, 0x000, 0x00F, 0x004, 0x002, 0x003,
-    0x000, 0x000, 0x002, 0x002, 0x002, 0x000, 0x000, 0x000, 0x005, 0x002, 0x008, 0x002, 0x000,
-    0x002, 0x000, 0x005, 0x006, 0x001, 0x009, 0x000, 0x001, 0x001, 0x004, 0x002, 0x001, 0x000,
-    0x000, 0x000, 0x002, 0x002, 0x003, 0x001, 0x005, 0x002, 0x000, 0x000, 0x004, 0x005, 0x001,
-    0x000, 0x001, 0x000, 0x009, 0x000, 0x002, 0x001, 0x000, 0x003, 0x000, 0x002, 0x002, 0x003,
-    0x000, 0x000, 0x009, 0x001, 0x003, 0x000, 0x001, 0x006, 0x003, 0x000, 0x002, 0x001, 0x007,
-    0x003, 0x000, 0x005, 0x000, 0x001, 0x000, 0x000, 0x000, 0x004, 0x005, 0x000, 0x001, 0x000,
-    0x003, 0x002, 0x001, 0x000, 0x002, 0x000, 0x001, 0x011, 0x001, 0x001, 0x004, 0x000, 0x001,
-    0x000, 0x001, 0x001, 0x000, 0x004, 0x003, 0x000, 0x000, 0x000, 0x002, 0x001, 0x000, 0x017,
-    0x004, 0x000, 0x000, 0x000, 0x003, 0x00C, 0x000, 0x008, 0x003, 0x002, 0x003, 0x005, 0x000,
-    0x002, 0x003, 0x002, 0x001, 0x000, 0x003, 0x000, 0x001, 0x001, 0x000, 0x001, 0x000, 0x004,
-    0x001, 0x006, 0x002, 0x01D, 0x004, 0x004, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x009,
-    0x002, 0x007, 0x002, 0x005, 0x000, 0x000, 0x009, 0x001, 0x004, 0x000, 0x001, 0x000, 0x000,
-    0x004, 0x007, 0x000, 0x006, 0x005, 0x000, 0x001, 0x001, 0x000, 0x003, 0x001, 0x001, 0x002,
-    0x000, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x001, 0x000, 0x002, 0x003, 0x005, 0x001,
-    0x007, 0x001, 0x001, 0x003, 0x002, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x000, 0x002, 0x002, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x004, 0x003, 0x002,
-    0x004, 0x000, 0x000, 0x001, 0x000, 0x000, 0x002, 0x00B, 0x008, 0x000, 0x004, 0x003, 0x001,
-    0x009, 0x003, 0x002, 0x001, 0x003, 0x000, 0x002, 0x005, 0x000, 0x005, 0x001, 0x003, 0x005,
-    0x002, 0x001, 0x003, 0x000, 0x010, 0x002, 0x000, 0x000, 0x000, 0x001, 0x000, 0x006, 0x000,
-    0x001, 0x003, 0x000, 0x008, 0x000, 0x000, 0x002, 0x006, 0x000, 0x004, 0x000, 0x000, 0x001,
-    0x000, 0x004, 0x000, 0x003, 0x001, 0x003, 0x000, 0x002, 0x003, 0x001, 0x005, 0x003, 0x005,
-    0x005, 0x001, 0x001, 0x001, 0x000, 0x006, 0x003, 0x001, 0x000, 0x001, 0x001, 0x000, 0x003,
-    0x002, 0x001, 0x006, 0x000, 0x005, 0x002, 0x003, 0x009, 0x007, 0x004, 0x000, 0x002, 0x002,
-    0x001, 0x002, 0x006, 0x000, 0x000, 0x000, 0x002, 0x000, 0x001, 0x000, 0x004, 0x003, 0x000,
-    0x002, 0x005, 0x012, 0x005, 0x002, 0x000, 0x001, 0x00D, 0x003, 0x004, 0x000, 0x000, 0x001,
-    0x002, 0x000, 0x00D, 0x000, 0x00D, 0x001, 0x000, 0x001, 0x000, 0x001, 0x001, 0x001, 0x001,
-    0x001, 0x001, 0x002, 0x000, 0x001, 0x005, 0x003, 0x000, 0x005, 0x000, 0x001, 0x000, 0x000,
-    0x004, 0x000, 0x002, 0x001, 0x000, 0x001, 0x002, 0x000, 0x000, 0x005, 0x000, 0x001, 0x000,
-    0x000, 0x000, 0x001, 0x000, 0x003, 0x000, 0x001, 0x002, 0x002, 0x000, 0x000, 0x001, 0x000,
-    0x005, 0x000, 0x00D, 0x000, 0x001, 0x002, 0x00A, 0x003, 0x000, 0x000, 0x002, 0x002, 0x001,
-    0x002, 0x000, 0x002, 0x001, 0x001, 0x005, 0x000, 0x00A, 0x000, 0x000, 0x003, 0x003, 0x009,
-    0x001, 0x004, 0x002, 0x002, 0x000, 0x000, 0x003, 0x006, 0x000, 0x000, 0x00A, 0x001, 0x003,
-    0x001, 0x00C, 0x000, 0x000, 0x000, 0x002, 0x001, 0x006, 0x001, 0x000, 0x001, 0x002, 0x007,
-    0x000, 0x000, 0x005, 0x002, 0x001, 0x000, 0x001, 0x001, 0x001, 0x000, 0x004, 0x000, 0x000,
-    0x001, 0x000, 0x001, 0x000, 0x001, 0x006, 0x000, 0x008, 0x000, 0x002, 0x004, 0x002, 0x004,
-    0x002, 0x002, 0x000, 0x002, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000, 0x005, 0x002, 0x006,
-    0x000, 0x001, 0x002, 0x005, 0x000, 0x000, 0x001, 0x000, 0x002, 0x000, 0x005, 0x000, 0x001,
-    0x001, 0x002, 0x003, 0x000, 0x000, 0x000, 0x000, 0x005, 0x000, 0x000, 0x001, 0x00D, 0x001,
-    0x000, 0x000, 0x000, 0x001, 0x000, 0x005, 0x002, 0x000, 0x007, 0x009, 0x001, 0x002, 0x002,
-    0x000, 0x001, 0x009, 0x007, 0x000, 0x005, 0x002, 0x000, 0x001, 0x001, 0x005, 0x006, 0x002,
-    0x000, 0x00F, 0x000, 0x001, 0x000, 0x005, 0x001, 0x002, 0x001, 0x002, 0x000, 0x000, 0x002,
-    0x003, 0x000, 0x007, 0x003, 0x000, 0x000, 0x003, 0x000, 0x002, 0x002, 0x001, 0x002, 0x001,
-    0x002, 0x005, 0x001, 0x000, 0x009, 0x000, 0x000, 0x000, 0x006, 0x009, 0x001, 0x00A, 0x001,
-    0x001, 0x000, 0x000, 0x003, 0x006, 0x000, 0x000, 0x000, 0x001, 0x002, 0x000, 0x000, 0x007,
-    0x002, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x003, 0x001, 0x000, 0x004, 0x001, 0x006,
-    0x002, 0x002, 0x000, 0x000, 0x004, 0x00B, 0x001, 0x000, 0x000, 0x005, 0x001, 0x003, 0x000,
-    0x002, 0x006, 0x008, 0x002, 0x000, 0x006, 0x000, 0x004, 0x001, 0x006, 0x000, 0x002, 0x003,
-    0x001, 0x001, 0x001, 0x003, 0x002, 0x002, 0x002, 0x002, 0x00C, 0x001, 0x000, 0x004, 0x005,
-    0x000, 0x004, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x002, 0x000, 0x000,
-    0x000, 0x001, 0x002, 0x000, 0x000, 0x008, 0x004, 0x001, 0x002, 0x000, 0x003, 0x001, 0x002,
-    0x000, 0x003, 0x003, 0x007, 0x000, 0x000, 0x000, 0x000, 0x001, 0x00B, 0x000, 0x001, 0x000,
-    0x000, 0x002, 0x001, 0x002, 0x001, 0x007, 0x001, 0x002, 0x003, 0x002, 0x000, 0x000, 0x001,
-    0x004, 0x001, 0x001, 0x001, 0x001, 0x001, 0x000, 0x00A, 0x001, 0x005, 0x000, 0x006, 0x000,
-    0x000, 0x000, 0x001, 0x003, 0x001, 0x007, 0x002, 0x000, 0x000, 0x001, 0x002, 0x001, 0x002,
-    0x000, 0x001, 0x001, 0x001, 0x001, 0x000, 0x006, 0x000, 0x000, 0x000, 0x000, 0x003, 0x005,
-    0x000, 0x003, 0x001, 0x002, 0x006, 0x001, 0x000, 0x001, 0x002, 0x000, 0x002, 0x003, 0x000,
-    0x001, 0x000, 0x003, 0x002, 0x00C, 0x001, 0x006, 0x008, 0x007, 0x002, 0x001, 0x003, 0x000,
-    0x006, 0x002, 0x000, 0x000, 0x001, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x000, 0x005,
-    0x000, 0x005, 0x000, 0x000, 0x001, 0x002, 0x001, 0x000, 0x001, 0x001, 0x000, 0x00A, 0x002,
-    0x000, 0x000, 0x00C, 0x000, 0x001, 0x000, 0x002, 0x003, 0x001, 0x004, 0x001, 0x002, 0x001,
-    0x000, 0x007, 0x001, 0x001, 0x008, 0x009, 0x002, 0x000, 0x002, 0x002, 0x003, 0x003, 0x001,
-    0x003, 0x002, 0x000, 0x000, 0x001, 0x000, 0x006, 0x005, 0x000, 0x002, 0x002, 0x000, 0x001,
-    0x002, 0x005, 0x004, 0x002, 0x001, 0x002, 0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x002,
-    0x000, 0x007, 0x005, 0x003, 0x000, 0x000, 0x001, 0x000, 0x004, 0x003, 0x000, 0x002, 0x007,
-    0x001, 0x000, 0x002, 0x000, 0x002, 0x004, 0x002, 0x000, 0x000, 0x002, 0x000, 0x00E, 0x001,
-    0x001, 0x000, 0x000, 0x003, 0x000, 0x003, 0x000, 0x000, 0x002, 0x000, 0x000, 0x006, 0x003,
-    0x003, 0x003, 0x001, 0x000, 0x001, 0x000, 0x000, 0x003, 0x000, 0x000, 0x000, 0x000, 0x001,
-    0x000, 0x007, 0x005, 0x001, 0x000, 0x001, 0x001, 0x003, 0x001, 0x009, 0x000, 0x000, 0x008,
-    0x000, 0x000, 0x00F, 0x002, 0x002, 0x000, 0x004, 0x000, 0x000, 0x000, 0x002, 0x000, 0x001,
-    0x007, 0x002, 0x001, 0x000, 0x001, 0x001, 0x002, 0x000, 0x000, 0x002, 0x000, 0x000, 0x002,
-    0x000, 0x002, 0x002, 0x001, 0x006, 0x000, 0x001, 0x000, 0x001, 0x004, 0x000, 0x002, 0x003,
-    0x001, 0x002, 0x000, 0x003, 0x002, 0x001, 0x000, 0x001, 0x000, 0x000, 0x000, 0x002, 0x000,
-    0x001, 0x004, 0x001, 0x00E, 0x003, 0x003, 0x000, 0x005, 0x001, 0x000, 0x000, 0x002, 0x001,
-    0x002, 0x000, 0x000, 0x003, 0x000, 0x002, 0x001, 0x000, 0x001, 0x000, 0x001, 0x002, 0x000,
-    0x001, 0x000, 0x001, 0x001, 0x001, 0x001, 0x005, 0x003, 0x000, 0x00A, 0x002, 0x002, 0x001,
-    0x000, 0x000, 0x004, 0x000, 0x002, 0x00A, 0x000, 0x000, 0x008, 0x004, 0x000, 0x001, 0x004,
-    0x005, 0x005, 0x002, 0x001, 0x000, 0x000, 0x000, 0x006, 0x000, 0x001, 0x001, 0x000, 0x000,
-    0x001, 0x001, 0x002, 0x001, 0x000, 0x001, 0x002, 0x002, 0x002, 0x000, 0x001, 0x001, 0x001,
-    0x002, 0x000, 0x001, 0x000, 0x001, 0x000, 0x001, 0x002, 0x001, 0x000, 0x001, 0x002, 0x000,
-    0x002, 0x002, 0x000, 0x000, 0x000, 0x003, 0x000, 0x001, 0x003, 0x001, 0x002, 0x007, 0x000,
-    0x002, 0x004, 0x004, 0x000, 0x005, 0x000, 0x000, 0x001, 0x003, 0x003, 0x000, 0x009, 0x001,
-    0x000, 0x001, 0x002, 0x004, 0x003, 0x001, 0x000, 0x001, 0x001, 0x002, 0x003, 0x001, 0x006,
-    0x003, 0x001, 0x003, 0x001, 0x005, 0x004, 0x001, 0x000, 0x001, 0x001, 0x000, 0x005, 0x001,
-    0x000, 0x001, 0x001, 0x002, 0x000, 0x005, 0x008, 0x001, 0x000, 0x007, 0x000, 0x000, 0x000,
-    0x005, 0x001, 0x000, 0x000, 0x001, 0x000, 0x001, 0x000, 0x000, 0x002, 0x002, 0x000, 0x000,
-    0x00A, 0x000, 0x000, 0x000, 0x001, 0x000, 0x001, 0x007, 0x002, 0x004, 0x000, 0x001, 0x005,
-    0x000, 0x001, 0x000, 0x000, 0x000, 0x004, 0x000, 0x000, 0x004, 0x002, 0x000, 0x002, 0x001,
-    0x001, 0x000, 0x002, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x002, 0x000, 0x000,
-    0x004, 0x000, 0x001, 0x000, 0x003, 0x003, 0x000, 0x001, 0x003, 0x001, 0x000, 0x001, 0x000,
-    0x000, 0x002, 0x000, 0x00A, 0x000, 0x001, 0x000, 0x000, 0x003, 0x001, 0x001, 0x005, 0x004,
-    0x003, 0x000, 0x000, 0x002, 0x001, 0x000, 0x001, 0x000, 0x001, 0x002, 0x002, 0x001, 0x000,
-    0x004, 0x001, 0x000, 0x003, 0x001, 0x001, 0x005, 0x001, 0x001, 0x007, 0x001, 0x003, 0x000,
-    0x000, 0x004, 0x003, 0x001, 0x002, 0x00B, 0x002, 0x001, 0x000, 0x000, 0x000, 0x001, 0x002,
-    0x001, 0x004, 0x003, 0x001, 0x001, 0x002, 0x000, 0x000, 0x002, 0x002, 0x000, 0x000, 0x000,
-    0x002, 0x002, 0x001, 0x000, 0x002, 0x000, 0x000, 0x001, 0x001, 0x008, 0x002, 0x001, 0x000,
-    0x003, 0x000, 0x001, 0x001, 0x001, 0x000, 0x003, 0x004, 0x002, 0x007, 0x003, 0x001, 0x009,
-    0x002, 0x005, 0x002, 0x002, 0x003, 0x000, 0x00F, 0x000, 0x002, 0x001, 0x003, 0x004, 0x001,
-    0x000, 0x003, 0x009, 0x002, 0x001, 0x008, 0x000, 0x001, 0x001, 0x000, 0x009, 0x000, 0x000,
-    0x001, 0x000, 0x00A, 0x000, 0x004, 0x001, 0x000, 0x002, 0x003, 0x009, 0x002, 0x000, 0x000,
-    0x005, 0x001, 0x002, 0x003, 0x002, 0x000, 0x001, 0x002, 0x002, 0x001, 0x003, 0x000, 0x000,
-    0x002, 0x001, 0x001, 0x000, 0x001, 0x005, 0x001, 0x002, 0x002, 0x002, 0x002, 0x002, 0x002,
-    0x008, 0x005, 0x000, 0x001, 0x001, 0x002, 0x000, 0x001, 0x000, 0x00B, 0x004, 0x000, 0x002,
-    0x002, 0x004, 0x000, 0x001, 0x002, 0x000, 0x000, 0x001, 0x001, 0x001, 0x001, 0x002, 0x000,
-    0x002, 0x000, 0x002, 0x005, 0x004, 0x000, 0x000, 0x000, 0x005, 0x000, 0x000, 0x003, 0x002,
-    0x001, 0x000, 0x000, 0x000, 0x003, 0x000, 0x002, 0x000, 0x000, 0x001, 0x002, 0x002, 0x001,
-    0x000, 0x001, 0x004, 0x001, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x002, 0x000,
-    0x004, 0x000, 0x001, 0x002, 0x000, 0x001, 0x002, 0x000, 0x000, 0x001, 0x000, 0x002, 0x002,
-    0x001, 0x001, 0x001, 0x000, 0x003, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x001, 0x008, 0x004, 0x001, 0x002, 0x007, 0x005, 0x000, 0x003, 0x002, 0x000, 0x002, 0x002,
-    0x004, 0x000, 0x004, 0x000, 0x004, 0x002, 0x001, 0x002, 0x002, 0x002, 0x001, 0x000, 0x000,
-    0x001, 0x003, 0x003, 0x001, 0x001, 0x002, 0x002, 0x000, 0x001, 0x001, 0x000, 0x001, 0x000,
-    0x001, 0x001, 0x003, 0x004, 0x001, 0x002, 0x002, 0x004, 0x000, 0x003, 0x001, 0x001, 0x001,
-    0x000, 0x003, 0x001, 0x000, 0x003, 0x002, 0x001, 0x000, 0x003, 0x002, 0x001, 0x006, 0x006,
-    0x000, 0x000, 0x002, 0x001, 0x000, 0x001, 0x002, 0x003, 0x002, 0x001, 0x003, 0x001, 0x000,
-    0x001, 0x005, 0x003, 0x001, 0x002, 0x004, 0x00D, 0x000, 0x001, 0x000, 0x000, 0x001, 0x000,
-    0x000, 0x001, 0x001, 0x001, 0x000, 0x000, 0x001, 0x001, 0x002, 0x000, 0x003, 0x003, 0x000,
-    0x001, 0x000, 0x002, 0x000, 0x005, 0x000, 0x001, 0x000, 0x001, 0x000, 0x000, 0x004, 0x001,
-    0x002, 0x000, 0x000, 0x002, 0x002, 0x000, 0x000, 0x001, 0x004, 0x002, 0x000, 0x000, 0x004,
-    0x001, 0x002, 0x000, 0x000, 0x000, 0x000, 0x001, 0x001, 0x002, 0x003, 0x000, 0x001, 0x002,
-    0x003, 0x001, 0x000, 0x002, 0x001, 0x001, 0x000, 0x003, 0x002, 0x001, 0x001, 0x000, 0x000,
-    0x003, 0x000, 0x003, 0x000, 0x000, 0x000, 0x003, 0x000, 0x002, 0x001, 0x001, 0x002, 0x000,
-    0x004, 0x000, 0x001, 0x000, 0x001, 0x006, 0x000, 0x004, 0x001, 0x002, 0x000, 0x000, 0x000,
-    0x000, 0x001, 0x002, 0x000, 0x002, 0x000, 0x002, 0x000, 0x001, 0x002, 0x001, 0x002, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x003, 0x000, 0x002, 0x001, 0x001, 0x000, 0x002, 0x000,
-    0x000, 0x003, 0x008, 0x003, 0x000, 0x000, 0x000, 0x002, 0x001, 0x000, 0x000, 0x000, 0x000,
-    0x001, 0x003, 0x003, 0x004, 0x000, 0x003, 0x001, 0x000, 0x001, 0x001, 0x000, 0x002, 0x004,
-    0x001, 0x002, 0x001, 0x004, 0x002, 0x001, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x001,
-    0x001, 0x008, 0x000, 0x003, 0x000, 0x001, 0x001, 0x004, 0x001, 0x002, 0x000, 0x001, 0x001,
-    0x000, 0x003, 0x001, 0x000, 0x008, 0x000, 0x000, 0x002, 0x001, 0x004, 0x005, 0x006, 0x001,
-    0x002, 0x000, 0x003, 0x003, 0x000, 0x001, 0x000, 0x003, 0x000, 0x004, 0x000, 0x005, 0x001,
-    0x002, 0x001, 0x003, 0x002, 0x004, 0x001, 0x001, 0x002, 0x001, 0x003, 0x005, 0x001, 0x003,
-    0x001, 0x000, 0x000, 0x003, 0x000, 0x003, 0x001, 0x005, 0x000, 0x001, 0x000, 0x001, 0x002,
-    0x001, 0x000, 0x004, 0x002, 0x002, 0x001, 0x002, 0x001, 0x005, 0x000, 0x001, 0x002, 0x001,
-    0x000, 0x000, 0x001, 0x00A, 0x003, 0x002, 0x002, 0x000, 0x004, 0x001, 0x000, 0x001, 0x000,
-    0x003, 0x000, 0x001, 0x001, 0x000, 0x001, 0x001, 0x002, 0x000, 0x001, 0x002, 0x000, 0x002,
-    0x000, 0x001, 0x002, 0x002, 0x003, 0x000, 0x003, 0x003, 0x004, 0x003, 0x000, 0x000, 0x007,
-    0x000, 0x002, 0x002, 0x000, 0x001, 0x002, 0x000, 0x000, 0x002, 0x000, 0x002, 0x000, 0x000,
-    0x001, 0x000, 0x001, 0x003, 0x002, 0x003, 0x002, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x001, 0x002, 0x001, 0x000, 0x001, 0x001, 0x000,
-];
-pub(crate) const COMPATIBILITY_DECOMPOSED_KV: &[(u32, (u16, u16))] = &[
-    (0x1D5E5, (0x12B4, 0x1)),
-    (0x1D430, (0x1117, 0x1)),
-    (0x0FDF1, (0xE6D, 0x3)),
-    (0x024DF, (0x33C, 0x1)),
-    (0x0FF18, (0xFC0, 0x1)),
-    (0x0FD72, (0xD6E, 0x3)),
-    (0x1D5A3, (0x1272, 0x1)),
-    (0x02000, (0x113, 0x1)),
-    (0x1D43F, (0x1126, 0x1)),
-    (0x03197, (0x49F, 0x1)),
-    (0x0FCCC, (0xC1F, 0x2)),
-    (0x033DA, (0x921, 0x2)),
-    (0x03289, (0x5EA, 0x1)),
-    (0x0FFEA, (0x1086, 0x1)),
-    (0x024E1, (0x33E, 0x1)),
-    (0x02155, (0x1C3, 0x3)),
-    (0x03298, (0x5F9, 0x1)),
-    (0x0FEF8, (0xF9C, 0x3)),
-    (0x0FF47, (0xFEF, 0x1)),
-    (0x0FBEC, (0xA3D, 0x3)),
-    (0x1D410, (0x10F7, 0x1)),
-    (0x02177, (0x20F, 0x4)),
-    (0x1D4D3, (0x11AE, 0x1)),
-    (0x0FD63, (0xD41, 0x3)),
-    (0x0335B, (0x7E8, 0x2)),
-    (0x0FED8, (0xF76, 0x1)),
-    (0x032B8, (0x620, 0x2)),
-    (0x1D5F4, (0x12C3, 0x1)),
-    (0x0FF27, (0xFCF, 0x1)),
-    (0x1E055, (0x14F0, 0x1)),
-    (0x0FFAC, (0x1054, 0x1)),
-    (0x01E9A, (0x0EA, 0x2)),
-    (0x1D532, (0x1208, 0x1)),
-    (0x0337A, (0x839, 0x2)),
-    (0x1E041, (0x14DC, 0x1)),
-    (0x02148, (0x1B1, 0x1)),
-    (0x1F21D, (0x1645, 0x1)),
-    (0x1D73C, (0x1409, 0x1)),
-    (0x01DA8, (0x0D2, 0x1)),
-    (0x02F4A, (0x3A3, 0x1)),
-    (0x0FF35, (0xFDD, 0x1)),
-    (0x1D48E, (0x1174, 0x1)),
-    (0x1EE10, (0x1518, 0x1)),
-    (0x02F7D, (0x3D6, 0x1)),
-    (0x02492, (0x2A7, 0x3)),
-    (0x0FB58, (0x9C1, 0x1)),
-    (0x1F227, (0x164F, 0x1)),
-    (0x02F4E, (0x3A7, 0x1)),
-    (0x1D652, (0x1321, 0x1)),
-    (0x1F106, (0x15A2, 0x2)),
-    (0x1D724, (0x13F1, 0x1)),
-    (0x1D6DA, (0x13A7, 0x1)),
-    (0x03204, (0x4B4, 0x3)),
-    (0x0FEE9, (0xF87, 0x1)),
-    (0x1F135, (0x1608, 0x1)),
-    (0x0203E, (0x134, 0x2)),
-    (0x1D46E, (0x1154, 0x1)),
-    (0x1D750, (0x141D, 0x1)),
-    (0x03399, (0x880, 0x2)),
-    (0x0FFD7, (0x1078, 0x1)),
-    (0x03211, (0x4DE, 0x4)),
-    (0x1D538, (0x120E, 0x1)),
-    (0x1E065, (0x1500, 0x1)),
-    (0x03315, (0x6D9, 0x6)),
-    (0x03382, (0x84B, 0x2)),
-    (0x03161, (0x46C, 0x1)),
-    (0x1D60A, (0x12D9, 0x1)),
-    (0x1D4E5, (0x11C0, 0x1)),
-    (0x02F24, (0x37D, 0x1)),
-    (0x0FE6B, (0xEF5, 0x1)),
-    (0x1D58F, (0x125E, 0x1)),
-    (0x0FEC2, (0xF60, 0x1)),
-    (0x0FC2E, (0xAD2, 0x2)),
-    (0x032F2, (0x677, 0x1)),
-    (0x0FF0C, (0xFB4, 0x1)),
-    (0x1E037, (0x14D2, 0x1)),
-    (0x1D7A1, (0x146E, 0x1)),
-    (0x03362, (0x7F6, 0x3)),
-    (0x0FB50, (0x9B9, 0x1)),
-    (0x1D7F2, (0x14BD, 0x1)),
-    (0x0FCA7, (0xBD5, 0x2)),
-    (0x1E059, (0x14F4, 0x1)),
-    (0x0FD99, (0xDDD, 0x3)),
-    (0x1D464, (0x114A, 0x1)),
-    (0x0FB78, (0x9E1, 0x1)),
-    (0x0FE58, (0xEE3, 0x1)),
-    (0x032EE, (0x673, 0x1)),
-    (0x107A8, (0x10B1, 0x1)),
-    (0x0FD5C, (0xD2C, 0x3)),
-    (0x0207E, (0x14D, 0x1)),
-    (0x0321A, (0x502, 0x4)),
-    (0x1D7D8, (0x14A3, 0x1)),
-    (0x01D40, (0x09A, 0x1)),
-    (0x0FCDE, (0xC43, 0x2)),
-    (0x1CCF7, (0x10E4, 0x1)),
-    (0x032A5, (0x606, 0x1)),
-    (0x0FC0C, (0xA8E, 0x2)),
-    (0x0FF40, (0xFE8, 0x1)),
-    (0x033C0, (0x8E2, 0x2)),
-    (0x0FC40, (0xAF6, 0x2)),
-    (0x1D5CD, (0x129C, 0x1)),
-    (0x1D7F8, (0x14C3, 0x1)),
-    (0x01DA1, (0x0CB, 0x1)),
-    (0x02F26, (0x37F, 0x1)),
-    (0x1D706, (0x13D3, 0x1)),
-    (0x0FF36, (0xFDE, 0x1)),
-    (0x0325A, (0x5A0, 0x2)),
-    (0x02F84, (0x3DD, 0x1)),
-    (0x0317D, (0x488, 0x1)),
-    (0x0FC16, (0xAA2, 0x2)),
-    (0x1D5B6, (0x1285, 0x1)),
-    (0x0FD3B, (0xD02, 0x2)),
-    (0x0313E, (0x449, 0x1)),
-    (0x1D69F, (0x136E, 0x1)),
-    (0x024A8, (0x2E9, 0x3)),
-    (0x1D50F, (0x11E7, 0x1)),
-    (0x0FD52, (0xD0E, 0x3)),
-    (0x02112, (0x187, 0x1)),
-    (0x0FDF0, (0xE6A, 0x3)),
-    (0x1D77A, (0x1447, 0x1)),
-    (0x0FF7E, (0x1026, 0x1)),
-    (0x1D7E0, (0x14AB, 0x1)),
-    (0x0FC07, (0xA84, 0x2)),
-    (0x0FB5B, (0x9C4, 0x1)),
-    (0x1D49C, (0x1182, 0x1)),
-    (0x0FE48, (0xED0, 0x1)),
-    (0x1F220, (0x1648, 0x1)),
-    (0x02F8B, (0x3E4, 0x1)),
-    (0x02048, (0x138, 0x2)),
-    (0x0FCEC, (0xC61, 0x2)),
-    (0x02F89, (0x3E2, 0x1)),
-    (0x0FC49, (0xB08, 0x2)),
-    (0x03293, (0x5F4, 0x1)),
-    (0x00385, (0x05C, 0x3)),
-    (0x0222C, (0x222, 0x2)),
-    (0x02FBA, (0x413, 0x1)),
-    (0x032C6, (0x63C, 0x2)),
-    (0x1D600, (0x12CF, 0x1)),
-    (0x1D58C, (0x125B, 0x1)),
-    (0x0FB71, (0x9DA, 0x1)),
-    (0x1D55F, (0x122E, 0x1)),
-    (0x1D494, (0x117A, 0x1)),
-    (0x0320C, (0x4CC, 0x3)),
-    (0x1D4E4, (0x11BF, 0x1)),
-    (0x01DB4, (0x0DE, 0x1)),
-    (0x0FF82, (0x102A, 0x1)),
-    (0x032B1, (0x612, 0x2)),
-    (0x02475, (0x24E, 0x3)),
-    (0x1D46B, (0x1151, 0x1)),
-    (0x01DA0, (0x0CA, 0x1)),
-    (0x1D4D4, (0x11AF, 0x1)),
-    (0x0FB8F, (0x9F8, 0x1)),
-    (0x1D7A2, (0x146F, 0x1)),
-    (0x02084, (0x153, 0x1)),
-    (0x1079A, (0x10A3, 0x1)),
-    (0x1D6F0, (0x13BD, 0x1)),
-    (0x107AF, (0x10B8, 0x1)),
-    (0x1D597, (0x1266, 0x1)),
-    (0x0FC14, (0xA9E, 0x2)),
-    (0x0319E, (0x4A6, 0x1)),
-    (0x03282, (0x5E3, 0x1)),
-    (0x10788, (0x1091, 0x1)),
-    (0x1EE22, (0x1529, 0x1)),
-    (0x0FD2A, (0xCE0, 0x2)),
-    (0x1F139, (0x160C, 0x1)),
-    (0x0FF0A, (0xFB2, 0x1)),
-    (0x03290, (0x5F1, 0x1)),
-    (0x1E039, (0x14D4, 0x1)),
-    (0x1F21E, (0x1646, 0x1)),
-    (0x03304, (0x697, 0x5)),
-    (0x1D6A1, (0x1370, 0x1)),
-    (0x024B3, (0x30A, 0x3)),
-    (0x03198, (0x4A0, 0x1)),
-    (0x1EE96, (0x1577, 0x1)),
-    (0x0FC41, (0xAF8, 0x2)),
-    (0x0FE3D, (0xEC7, 0x1)),
-    (0x1D73B, (0x1408, 0x1)),
-    (0x0A69D, (0x987, 0x1)),
-    (0x1D5AF, (0x127E, 0x1)),
-    (0x0316F, (0x47A, 0x1)),
-    (0x0FEF7, (0xF99, 0x3)),
-    (0x033E8, (0x93F, 0x2)),
-    (0x024BE, (0x31B, 0x1)),
-    (0x033BB, (0x8D8, 0x2)),
-    (0x033EC, (0x94A, 0x3)),
-    (0x0329F, (0x600, 0x1)),
-    (0x1D402, (0x10E9, 0x1)),
-    (0x02092, (0x160, 0x1)),
-    (0x033EE, (0x950, 0x3)),
-    (0x0FEA2, (0xF40, 0x1)),
-    (0x1D4D2, (0x11AD, 0x1)),
-    (0x0328A, (0x5EB, 0x1)),
-    (0x0FFA5, (0x104D, 0x1)),
-    (0x03299, (0x5FA, 0x1)),
-    (0x1D5C4, (0x1293, 0x1)),
-    (0x1D6B6, (0x1383, 0x1)),
-    (0x0FF08, (0xFB0, 0x1)),
-    (0x1D7EA, (0x14B5, 0x1)),
-    (0x02F15, (0x36E, 0x1)),
-    (0x024AB, (0x2F2, 0x3)),
-    (0x033D9, (0x91E, 0x3)),
-    (0x0FFE3, (0x107F, 0x2)),
-    (0x1D6E2, (0x13AF, 0x1)),
-    (0x1D728, (0x13F5, 0x1)),
-    (0x0FCAE, (0xBE3, 0x2)),
-    (0x02121, (0x193, 0x3)),
-    (0x1D422, (0x1109, 0x1)),
-    (0x1D41E, (0x1105, 0x1)),
-    (0x01D3F, (0x099, 0x1)),
-    (0x0FF86, (0x102E, 0x1)),
-    (0x0FDC1, (0xE55, 0x3)),
-    (0x0FC45, (0xB00, 0x2)),
-    (0x1CCDB, (0x10C8, 0x1)),
-    (0x1D50A, (0x11E4, 0x1)),
-    (0x1079D, (0x10A6, 0x1)),
-    (0x00140, (0x01E, 0x2)),
-    (0x1D76C, (0x1439, 0x1)),
-    (0x0FED4, (0xF72, 0x1)),
-    (0x1D67A, (0x1349, 0x1)),
-    (0x1F11B, (0x15CD, 0x3)),
-    (0x002B7, (0x045, 0x1)),
-    (0x1D458, (0x113E, 0x1)),
-    (0x0FD8E, (0xDC2, 0x3)),
-    (0x0FEB3, (0xF51, 0x1)),
-    (0x0FB5F, (0x9C8, 0x1)),
-    (0x02FC9, (0x422, 0x1)),
-    (0x024CC, (0x329, 0x1)),
-    (0x1D4A9, (0x1188, 0x1)),
-    (0x0FD31, (0xCEE, 0x2)),
-    (0x001C4, (0x023, 0x3)),
-    (0x03156, (0x461, 0x1)),
-    (0x1D4F3, (0x11CE, 0x1)),
-    (0x024C8, (0x325, 0x1)),
-    (0x0FB02, (0x997, 0x2)),
-    (0x0FBDD, (0xA29, 0x2)),
-    (0x1D768, (0x1435, 0x1)),
-    (0x002B6, (0x044, 0x1)),
-    (0x0FB7C, (0x9E5, 0x1)),
-    (0x02146, (0x1AF, 0x1)),
-    (0x0FFC2, (0x1067, 0x1)),
-    (0x1D6A2, (0x1371, 0x1)),
-    (0x02006, (0x119, 0x1)),
-    (0x1D445, (0x112C, 0x1)),
-    (0x0FF0B, (0xFB3, 0x1)),
-    (0x1D5FA, (0x12C9, 0x1)),
-    (0x02F0A, (0x363, 0x1)),
-    (0x02F14, (0x36D, 0x1)),
-    (0x0FE6A, (0xEF4, 0x1)),
-    (0x1D6C2, (0x138F, 0x1)),
-    (0x0FD7D, (0xD8F, 0x3)),
-    (0x03370, (0x820, 0x3)),
-    (0x0326F, (0x5BC, 0x2)),
-    (0x1EE2A, (0x152D, 0x1)),
-    (0x0FC86, (0xB8E, 0x2)),
-    (0x0FF12, (0xFBA, 0x1)),
-    (0x02F05, (0x35E, 0x1)),
-    (0x0FBE1, (0xA2E, 0x1)),
-    (0x1EE1B, (0x1523, 0x1)),
-    (0x0216A, (0x1F8, 0x2)),
-    (0x0FC78, (0xB72, 0x2)),
-    (0x1D4BE, (0x119A, 0x1)),
-    (0x03366, (0x802, 0x3)),
-    (0x1D69E, (0x136D, 0x1)),
-    (0x03182, (0x48D, 0x1)),
-    (0x1D425, (0x110C, 0x1)),
-    (0x1D760, (0x142D, 0x1)),
-    (0x02139, (0x1A5, 0x1)),
-    (0x0FDA5, (0xE01, 0x3)),
-    (0x033B8, (0x8D2, 0x2)),
-    (0x0FB03, (0x999, 0x3)),
-    (0x1D461, (0x1147, 0x1)),
-    (0x1D58B, (0x125A, 0x1)),
-    (0x0FC7E, (0xB7E, 0x2)),
-    (0x1D7ED, (0x14B8, 0x1)),
-    (0x1E047, (0x14E2, 0x1)),
-    (0x033C4, (0x8EC, 0x2)),
-    (0x1EEB0, (0x158A, 0x1)),
-    (0x02467, (0x233, 0x1)),
-    (0x1D4C8, (0x11A3, 0x1)),
-    (0x0FF70, (0x1018, 0x1)),
-    (0x0FC30, (0xAD6, 0x2)),
-    (0x1EE79, (0x155D, 0x1)),
-    (0x0FDC5, (0xE61, 0x3)),
-    (0x1D70D, (0x13DA, 0x1)),
-    (0x0FF61, (0x1009, 0x1)),
-    (0x1D7DE, (0x14A9, 0x1)),
-    (0x1D416, (0x10FD, 0x1)),
-    (0x0FF90, (0x1038, 0x1)),
-    (0x03390, (0x86A, 0x2)),
-    (0x1CCDD, (0x10CA, 0x1)),
-    (0x1078D, (0x1096, 0x1)),
-    (0x1EEA8, (0x1583, 0x1)),
-    (0x0FC50, (0xB16, 0x2)),
-    (0x1D572, (0x1241, 0x1)),
-    (0x0FED7, (0xF75, 0x1)),
-    (0x1D629, (0x12F8, 0x1)),
-    (0x1D693, (0x1362, 0x1)),
-    (0x0FDAC, (0xE16, 0x3)),
-    (0x033C3, (0x8EA, 0x2)),
-    (0x0FEF2, (0xF90, 0x1)),
-    (0x02156, (0x1C6, 0x3)),
-    (0x1F241, (0x1667, 0x3)),
-    (0x0203C, (0x132, 0x2)),
-    (0x1D40F, (0x10F6, 0x1)),
-    (0x02165, (0x1EC, 0x2)),
-    (0x003F1, (0x069, 0x1)),
-    (0x107A2, (0x10AB, 0x1)),
-    (0x0FB8D, (0x9F6, 0x1)),
-    (0x0FC24, (0xABE, 0x2)),
-    (0x1D510, (0x11E8, 0x1)),
-    (0x03239, (0x566, 0x3)),
-    (0x1D67E, (0x134D, 0x1)),
-    (0x0320D, (0x4CF, 0x3)),
-    (0x03330, (0x749, 0x3)),
-    (0x1D735, (0x1402, 0x1)),
-    (0x0FB72, (0x9DB, 0x1)),
-    (0x1EE51, (0x1543, 0x1)),
-    (0x1D635, (0x1304, 0x1)),
-    (0x0FC26, (0xAC2, 0x2)),
-    (0x1F218, (0x1640, 0x1)),
-    (0x02145, (0x1AE, 0x1)),
-    (0x01DB8, (0x0E2, 0x1)),
-    (0x1D79B, (0x1468, 0x1)),
-    (0x0314C, (0x457, 0x1)),
-    (0x0FC9C, (0xBBF, 0x2)),
-    (0x0FCEF, (0xC67, 0x2)),
-    (0x032DD, (0x662, 0x1)),
-    (0x0212C, (0x19A, 0x1)),
-    (0x1D488, (0x116E, 0x1)),
-    (0x02F68, (0x3C1, 0x1)),
-    (0x1E05B, (0x14F6, 0x1)),
-    (0x1E03D, (0x14D8, 0x1)),
-    (0x032B2, (0x614, 0x2)),
-    (0x0FD76, (0xD7A, 0x3)),
-    (0x0FD6F, (0xD65, 0x3)),
-    (0x1F141, (0x1614, 0x1)),
-    (0x1D627, (0x12F6, 0x1)),
-    (0x0FF97, (0x103F, 0x1)),
-    (0x02F9E, (0x3F7, 0x1)),
-    (0x0FD1A, (0xCC0, 0x2)),
-    (0x1F10A, (0x15AA, 0x2)),
-    (0x02FB7, (0x410, 0x1)),
-    (0x0FCDD, (0xC41, 0x2)),
-    (0x0FC10, (0xA96, 0x2)),
-    (0x03347, (0x7A1, 0x5)),
-    (0x03369, (0x80B, 0x3)),
-    (0x033C6, (0x8F0, 0x4)),
-    (0x0330F, (0x6C1, 0x4)),
-    (0x02F98, (0x3F1, 0x1)),
-    (0x0FB8A, (0x9F3, 0x1)),
-    (0x0FD56, (0xD1A, 0x3)),
-    (0x1D44C, (0x1133, 0x1)),
-    (0x1D68C, (0x135B, 0x1)),
-    (0x0FDB3, (0xE2B, 0x3)),
-    (0x02FAE, (0x407, 0x1)),
-    (0x1CCD6, (0x10C3, 0x1)),
-    (0x0FFB0, (0x1058, 0x1)),
-    (0x1D60E, (0x12DD, 0x1)),
-    (0x02070, (0x141, 0x1)),
-    (0x0AB69, (0x992, 0x1)),
-    (0x1E068, (0x1503, 0x1)),
-    (0x03140, (0x44B, 0x1)),
-    (0x0FFAE, (0x1056, 0x1)),
-    (0x03155, (0x460, 0x1)),
-    (0x0FB51, (0x9BA, 0x1)),
-    (0x01DBB, (0x0E5, 0x1)),
-    (0x02466, (0x232, 0x1)),
-    (0x1D729, (0x13F6, 0x1)),
-    (0x0FBFF, (0xA70, 0x1)),
-    (0x003D0, (0x05F, 0x1)),
-    (0x033D2, (0x90B, 0x3)),
-    (0x1F112, (0x15B2, 0x3)),
-    (0x01D37, (0x092, 0x1)),
-    (0x02057, (0x13C, 0x4)),
-    (0x0314F, (0x45A, 0x1)),
-    (0x002B3, (0x041, 0x1)),
-    (0x0FF64, (0x100C, 0x1)),
-    (0x0FEAE, (0xF4C, 0x1)),
-    (0x1F244, (0x1670, 0x3)),
-    (0x02F71, (0x3CA, 0x1)),
-    (0x0FE13, (0xEB0, 0x1)),
-    (0x02135, (0x1A1, 0x1)),
-    (0x0FF5A, (0x1002, 0x1)),
-    (0x03143, (0x44E, 0x1)),
-    (0x1D552, (0x1221, 0x1)),
-    (0x03339, (0x76E, 0x3)),
-    (0x0FCCA, (0xC1B, 0x2)),
-    (0x0FD19, (0xCBE, 0x2)),
-    (0x1D487, (0x116D, 0x1)),
-    (0x003F4, (0x06B, 0x1)),
-    (0x1E035, (0x14D0, 0x1)),
-    (0x0FD84, (0xDA4, 0x3)),
-    (0x1D4FA, (0x11D5, 0x1)),
-    (0x1D51B, (0x11F2, 0x1)),
-    (0x0FB7A, (0x9E3, 0x1)),
-    (0x0FFC7, (0x106C, 0x1)),
-    (0x1EE6D, (0x1553, 0x1)),
-    (0x024D3, (0x330, 0x1)),
-    (0x0FFEE, (0x108A, 0x1)),
-    (0x1D777, (0x1444, 0x1)),
-    (0x0FF34, (0xFDC, 0x1)),
-    (0x1D5DE, (0x12AD, 0x1)),
-    (0x1D482, (0x1168, 0x1)),
-    (0x1EE2B, (0x152E, 0x1)),
-    (0x024E6, (0x343, 0x1)),
-    (0x1EE67, (0x154E, 0x1)),
-    (0x0210B, (0x180, 0x1)),
-    (0x0FB75, (0x9DE, 0x1)),
-    (0x0FFD6, (0x1077, 0x1)),
-    (0x1D5E8, (0x12B7, 0x1)),
-    (0x01D56, (0x0AF, 0x1)),
-    (0x0FBE4, (0xA31, 0x1)),
-    (0x1F23A, (0x1662, 0x1)),
-    (0x0FD6B, (0xD59, 0x3)),
-    (0x1F235, (0x165D, 0x1)),
-    (0x0FDFC, (0xEA9, 0x4)),
-    (0x0FF9F, (0x1047, 0x1)),
-    (0x1EE80, (0x1562, 0x1)),
-    (0x1D485, (0x116B, 0x1)),
-    (0x0FD59, (0xD23, 0x3)),
-    (0x0FE34, (0xEBE, 0x1)),
-    (0x0FF41, (0xFE9, 0x1)),
-    (0x0FD6A, (0xD56, 0x3)),
-    (0x01DAF, (0x0D9, 0x1)),
-    (0x03176, (0x481, 0x1)),
-    (0x0FBD8, (0xA24, 0x1)),
-    (0x0FBA2, (0xA0B, 0x1)),
-    (0x02F2F, (0x388, 0x1)),
-    (0x1F13B, (0x160E, 0x1)),
-    (0x1D440, (0x1127, 0x1)),
-    (0x0FECD, (0xF6B, 0x1)),
-    (0x03138, (0x443, 0x1)),
-    (0x0FDC7, (0xE67, 0x3)),
-    (0x1D74A, (0x1417, 0x1)),
-    (0x0FEEC, (0xF8A, 0x1)),
-    (0x0316A, (0x475, 0x1)),
-    (0x02F8C, (0x3E5, 0x1)),
-    (0x033B1, (0x8C4, 0x2)),
-    (0x0FF2E, (0xFD6, 0x1)),
-    (0x02F3B, (0x394, 0x1)),
-    (0x1D63F, (0x130E, 0x1)),
-    (0x1D5C9, (0x1298, 0x1)),
-    (0x1D4B8, (0x1196, 0x1)),
-    (0x024B1, (0x304, 0x3)),
-    (0x1D45B, (0x1141, 0x1)),
-    (0x03170, (0x47B, 0x1)),
-    (0x1D7E3, (0x14AE, 0x1)),
-    (0x0FEB5, (0xF53, 0x1)),
-    (0x0339C, (0x886, 0x2)),
-    (0x0FC8C, (0xB9A, 0x2)),
-    (0x0FBDE, (0xA2B, 0x1)),
-    (0x0FD0A, (0xCA0, 0x2)),
-    (0x1E052, (0x14ED, 0x1)),
-    (0x0FD9B, (0xDE3, 0x3)),
-    (0x0331E, (0x704, 0x4)),
-    (0x02FB3, (0x40C, 0x1)),
-    (0x024E8, (0x345, 0x1)),
-    (0x033AF, (0x8BC, 0x6)),
-    (0x1D7AD, (0x147A, 0x1)),
-    (0x1EEAE, (0x1588, 0x1)),
-    (0x03303, (0x694, 0x3)),
-    (0x02470, (0x243, 0x2)),
-    (0x1D6DF, (0x13AC, 0x1)),
-    (0x0FF8B, (0x1033, 0x1)),
-    (0x1079E, (0x10A7, 0x1)),
-    (0x1D5C1, (0x1290, 0x1)),
-    (0x0FB24, (0x9B1, 0x1)),
-    (0x1D79C, (0x1469, 0x1)),
-    (0x1F133, (0x1606, 0x1)),
-    (0x0335A, (0x7E6, 0x2)),
-    (0x0FE19, (0xEB6, 0x3)),
-    (0x0208C, (0x15B, 0x1)),
-    (0x1D680, (0x134F, 0x1)),
-    (0x1D5D6, (0x12A5, 0x1)),
-    (0x1EEB8, (0x1592, 0x1)),
-    (0x01D58, (0x0B1, 0x1)),
-    (0x032F9, (0x67E, 0x1)),
-    (0x0FD86, (0xDAA, 0x3)),
-    (0x107B4, (0x10BC, 0x1)),
-    (0x0338E, (0x866, 0x2)),
-    (0x0FC35, (0xAE0, 0x2)),
-    (0x02C7D, (0x355, 0x1)),
-    (0x1EE35, (0x1537, 0x1)),
-    (0x0FD0E, (0xCA8, 0x2)),
-    (0x0325F, (0x5AA, 0x2)),
-    (0x033F2, (0x95C, 0x3)),
-    (0x01D4F, (0x0A8, 0x1)),
-    (0x1D6D2, (0x139F, 0x1)),
-    (0x0FC76, (0xB6E, 0x2)),
-    (0x1D406, (0x10ED, 0x1)),
-    (0x000BC, (0x00F, 0x3)),
-    (0x1F231, (0x1659, 0x1)),
-    (0x1EE89, (0x156B, 0x1)),
-    (0x1D415, (0x10FC, 0x1)),
-    (0x0FDF8, (0xE88, 0x4)),
-    (0x1D42B, (0x1112, 0x1)),
-    (0x0FCD5, (0xC31, 0x2)),
-    (0x0FCA5, (0xBD1, 0x2)),
-    (0x1D701, (0x13CE, 0x1)),
-    (0x0FF13, (0xFBB, 0x1)),
-    (0x1D41A, (0x1101, 0x1)),
-    (0x1D775, (0x1442, 0x1)),
-    (0x1D469, (0x114F, 0x1)),
-    (0x03284, (0x5E5, 0x1)),
-    (0x032BF, (0x62E, 0x2)),
-    (0x03322, (0x716, 0x3)),
-    (0x0FCF9, (0xC7E, 0x2)),
-    (0x02F45, (0x39E, 0x1)),
-    (0x0FD28, (0xCDC, 0x2)),
-    (0x03376, (0x82F, 0x2)),
-    (0x1D771, (0x143E, 0x1)),
-    (0x02F78, (0x3D1, 0x1)),
-    (0x0FF80, (0x1028, 0x1)),
-    (0x1D498, (0x117E, 0x1)),
-    (0x1F13F, (0x1612, 0x1)),
-    (0x1D710, (0x13DD, 0x1)),
-    (0x0FEBF, (0xF5D, 0x1)),
-    (0x032D1, (0x656, 0x1)),
-    (0x024BA, (0x317, 0x1)),
-    (0x1D6DC, (0x13A9, 0x1)),
-    (0x1D556, (0x1225, 0x1)),
-    (0x0FF38, (0xFE0, 0x1)),
-    (0x1D700, (0x13CD, 0x1)),
-    (0x0FC7B, (0xB78, 0x2)),
-    (0x02025, (0x122, 0x2)),
-    (0x0FD5E, (0xD32, 0x3)),
-    (0x0FE90, (0xF2E, 0x1)),
-    (0x1D78E, (0x145B, 0x1)),
-    (0x1D7DD, (0x14A8, 0x1)),
-    (0x0FF51, (0xFF9, 0x1)),
-    (0x1D648, (0x1317, 0x1)),
-    (0x1D73F, (0x140C, 0x1)),
-    (0x0328E, (0x5EF, 0x1)),
-    (0x1D795, (0x1462, 0x1)),
-    (0x02488, (0x292, 0x2)),
-    (0x024A6, (0x2E3, 0x3)),
-    (0x0319C, (0x4A4, 0x1)),
-    (0x1D717, (0x13E4, 0x1)),
-    (0x1D409, (0x10F0, 0x1)),
-    (0x1D4D8, (0x11B3, 0x1)),
-    (0x1D7FE, (0x14C9, 0x1)),
-    (0x03367, (0x805, 0x3)),
-    (0x0FF78, (0x1020, 0x1)),
-    (0x1D404, (0x10EB, 0x1)),
-    (0x1D43A, (0x1121, 0x1)),
-    (0x0FF88, (0x1030, 0x1)),
-    (0x0202F, (0x127, 0x1)),
-    (0x1D418, (0x10FF, 0x1)),
-    (0x0338C, (0x862, 0x2)),
-    (0x00EDD, (0x07E, 0x2)),
-    (0x1D5F1, (0x12C0, 0x1)),
-    (0x1D4C2, (0x119E, 0x1)),
-    (0x0FF24, (0xFCC, 0x1)),
-    (0x0FE49, (0xED1, 0x2)),
-    (0x0246E, (0x23F, 0x2)),
-    (0x0FFCF, (0x1072, 0x1)),
-    (0x02F0B, (0x364, 0x1)),
-    (0x01FDF, (0x106, 0x3)),
-    (0x1D6FA, (0x13C7, 0x1)),
-    (0x1D616, (0x12E5, 0x1)),
-    (0x0246D, (0x23D, 0x2)),
-    (0x0FEE7, (0xF85, 0x1)),
-    (0x0FC5B, (0xB2C, 0x2)),
-    (0x003D2, (0x061, 0x1)),
-    (0x1D524, (0x11FA, 0x1)),
-    (0x0336F, (0x81D, 0x3)),
-    (0x0FBB1, (0xA1D, 0x2)),
-    (0x0FCAF, (0xBE5, 0x2)),
-    (0x02151, (0x1B6, 0x3)),
-    (0x02F7F, (0x3D8, 0x1)),
-    (0x0337B, (0x83B, 0x2)),
-    (0x1F219, (0x1641, 0x1)),
-    (0x1EEA7, (0x1582, 0x1)),
-    (0x0334A, (0x7AC, 0x6)),
-    (0x1E05C, (0x14F7, 0x1)),
-    (0x03235, (0x55A, 0x3)),
-    (0x0FF5B, (0x1003, 0x1)),
-    (0x1D608, (0x12D7, 0x1)),
-    (0x03375, (0x82D, 0x2)),
-    (0x02F6C, (0x3C5, 0x1)),
-    (0x1CCF2, (0x10DF, 0x1)),
-    (0x1D47B, (0x1161, 0x1)),
-    (0x1D62F, (0x12FE, 0x1)),
-    (0x032F3, (0x678, 0x1)),
-    (0x032AC, (0x60D, 0x1)),
-    (0x1D721, (0x13EE, 0x1)),
-    (0x1EE70, (0x1556, 0x1)),
-    (0x000BE, (0x015, 0x3)),
-    (0x033E5, (0x939, 0x2)),
-    (0x0FE7F, (0xF10, 0x2)),
-    (0x1D55D, (0x122C, 0x1)),
-    (0x0337C, (0x83D, 0x2)),
-    (0x0FBA7, (0xA12, 0x1)),
-    (0x1D5B1, (0x1280, 0x1)),
-    (0x033FC, (0x97A, 0x3)),
-    (0x1D6AA, (0x1377, 0x1)),
-    (0x1D4DF, (0x11BA, 0x1)),
-    (0x1D45F, (0x1145, 0x1)),
-    (0x1E032, (0x14CD, 0x1)),
-    (0x01D48, (0x0A2, 0x1)),
-    (0x1D769, (0x1436, 0x1)),
-    (0x1D704, (0x13D1, 0x1)),
-    (0x1D621, (0x12F0, 0x1)),
-    (0x033D1, (0x909, 0x2)),
-    (0x0FDBF, (0xE4F, 0x3)),
-    (0x1D73E, (0x140B, 0x1)),
-    (0x0322D, (0x542, 0x3)),
-    (0x0FB27, (0x9B4, 0x1)),
-    (0x1F22A, (0x1652, 0x1)),
-    (0x0FE17, (0xEB4, 0x1)),
-    (0x01D31, (0x08C, 0x1)),
-    (0x0FCFC, (0xC84, 0x2)),
-    (0x03218, (0x4FA, 0x4)),
-    (0x1F14D, (0x1623, 0x2)),
-    (0x0FD07, (0xC9A, 0x2)),
-    (0x0330A, (0x6AF, 0x3)),
-    (0x02F64, (0x3BD, 0x1)),
-    (0x02F60, (0x3B9, 0x1)),
-    (0x02002, (0x115, 0x1)),
-    (0x0FF72, (0x101A, 0x1)),
-    (0x0FD11, (0xCAE, 0x2)),
-    (0x1D66F, (0x133E, 0x1)),
-    (0x1EEBB, (0x1595, 0x1)),
-    (0x01DA6, (0x0D0, 0x1)),
-    (0x0FB21, (0x9AE, 0x1)),
-    (0x1D450, (0x1137, 0x1)),
-    (0x1D670, (0x133F, 0x1)),
-    (0x02477, (0x254, 0x3)),
-    (0x0FD36, (0xCF8, 0x2)),
-    (0x0FC44, (0xAFE, 0x2)),
-    (0x1EEB5, (0x158F, 0x1)),
-    (0x02153, (0x1BD, 0x3)),
-    (0x1D787, (0x1454, 0x1)),
-    (0x0FC8D, (0xB9C, 0x2)),
-    (0x1D40C, (0x10F3, 0x1)),
-    (0x0FC62, (0xB3E, 0x3)),
-    (0x107B9, (0x10C1, 0x1)),
-    (0x03384, (0x84F, 0x2)),
-    (0x1EE77, (0x155C, 0x1)),
-    (0x0FCC1, (0xC09, 0x2)),
-    (0x0FCB8, (0xBF7, 0x2)),
-    (0x0335D, (0x7EC, 0x2)),
-    (0x1F11C, (0x15D0, 0x3)),
-    (0x1D5AD, (0x127C, 0x1)),
-    (0x0FB9B, (0xA04, 0x1)),
-    (0x01FCE, (0x0FA, 0x3)),
-    (0x01D5D, (0x0B6, 0x1)),
-    (0x032FA, (0x67F, 0x1)),
-    (0x032DB, (0x660, 0x1)),
-    (0x0FEE5, (0xF83, 0x1)),
-    (0x0FE41, (0xECB, 0x1)),
-    (0x0FF04, (0xFAC, 0x1)),
-    (0x0208D, (0x15C, 0x1)),
-    (0x024CE, (0x32B, 0x1)),
-    (0x0FD92, (0xDC8, 0x3)),
-    (0x1D441, (0x1128, 0x1)),
-    (0x1078A, (0x1093, 0x1)),
-    (0x02F73, (0x3CC, 0x1)),
-    (0x02111, (0x186, 0x1)),
-    (0x1078E, (0x1097, 0x1)),
-    (0x033CD, (0x901, 0x2)),
-    (0x0249A, (0x2BF, 0x3)),
-    (0x1D7CE, (0x1499, 0x1)),
-    (0x0FF67, (0x100F, 0x1)),
-    (0x0FC74, (0xB6A, 0x2)),
-    (0x0FC89, (0xB94, 0x2)),
-    (0x0217F, (0x21E, 0x1)),
-    (0x02168, (0x1F5, 0x2)),
-    (0x1D59D, (0x126C, 0x1)),
-    (0x03261, (0x5AD, 0x1)),
-    (0x1D68F, (0x135E, 0x1)),
-    (0x0FB63, (0x9CC, 0x1)),
-    (0x1EE37, (0x1539, 0x1)),
-    (0x1D56C, (0x123B, 0x1)),
-    (0x03171, (0x47C, 0x1)),
-    (0x1D56D, (0x123C, 0x1)),
-    (0x0FE4A, (0xED3, 0x2)),
-    (0x1EEA2, (0x157E, 0x1)),
-    (0x0FE5E, (0xEE9, 0x1)),
-    (0x1D6B4, (0x1381, 0x1)),
-    (0x1D69B, (0x136A, 0x1)),
-    (0x0208E, (0x15D, 0x1)),
-    (0x0FE98, (0xF36, 0x1)),
-    (0x1D61E, (0x12ED, 0x1)),
-    (0x1D439, (0x1120, 0x1)),
-    (0x02172, (0x204, 0x3)),
-    (0x02F30, (0x389, 0x1)),
-    (0x1D52B, (0x1201, 0x1)),
-    (0x1D49B, (0x1181, 0x1)),
-    (0x02109, (0x17D, 0x2)),
-    (0x0FF50, (0xFF8, 0x1)),
-    (0x0315C, (0x467, 0x1)),
-    (0x0335F, (0x7F0, 0x2)),
-    (0x0314E, (0x459, 0x1)),
-    (0x03267, (0x5B3, 0x1)),
-    (0x02F74, (0x3CD, 0x1)),
-    (0x0FC93, (0xBA8, 0x2)),
-    (0x1EE98, (0x1579, 0x1)),
-    (0x1F243, (0x166D, 0x3)),
-    (0x01D60, (0x0B9, 0x1)),
-    (0x0FF62, (0x100A, 0x1)),
-    (0x1D6D9, (0x13A6, 0x1)),
-    (0x03167, (0x472, 0x1)),
-    (0x02480, (0x272, 0x4)),
-    (0x0FD69, (0xD53, 0x3)),
-    (0x033E0, (0x92F, 0x2)),
-    (0x03175, (0x480, 0x1)),
-    (0x0FC15, (0xAA0, 0x2)),
-    (0x1D536, (0x120C, 0x1)),
-    (0x0FBF8, (0xA61, 0x3)),
-    (0x0FE3B, (0xEC5, 0x1)),
-    (0x0211B, (0x18E, 0x1)),
-    (0x024AD, (0x2F8, 0x3)),
-    (0x1CCE3, (0x10D0, 0x1)),
-    (0x0331F, (0x708, 0x4)),
-    (0x0FE72, (0xEFA, 0x2)),
-    (0x1D65D, (0x132C, 0x1)),
-    (0x0FC6B, (0xB58, 0x2)),
-    (0x1D56B, (0x123A, 0x1)),
-    (0x0217C, (0x21B, 0x1)),
-    (0x1D7E4, (0x14AF, 0x1)),
-    (0x1D586, (0x1255, 0x1)),
-    (0x0FC8B, (0xB98, 0x2)),
-    (0x1D4A2, (0x1185, 0x1)),
-    (0x0FD53, (0xD11, 0x3)),
-    (0x0A770, (0x988, 0x1)),
-    (0x1D517, (0x11EE, 0x1)),
-    (0x1D7AA, (0x1477, 0x1)),
-    (0x1EE6F, (0x1555, 0x1)),
-    (0x1D559, (0x1228, 0x1)),
-    (0x00675, (0x070, 0x2)),
-    (0x03337, (0x767, 0x3)),
-    (0x107B6, (0x10BE, 0x1)),
-    (0x0FED0, (0xF6E, 0x1)),
-    (0x001F3, (0x03C, 0x2)),
-    (0x1CCD8, (0x10C5, 0x1)),
-    (0x0FF17, (0xFBF, 0x1)),
-    (0x1F22D, (0x1655, 0x1)),
-    (0x10791, (0x109A, 0x1)),
-    (0x1D78A, (0x1457, 0x1)),
-    (0x1EE2D, (0x1530, 0x1)),
-    (0x033D0, (0x907, 0x2)),
-    (0x0FB04, (0x99C, 0x3)),
-    (0x01D66, (0x0BF, 0x1)),
-    (0x0332B, (0x730, 0x6)),
-    (0x1F16A, (0x162A, 0x2)),
-    (0x1D7AF, (0x147C, 0x1)),
-    (0x0FC90, (0xBA2, 0x2)),
-    (0x0FF1E, (0xFC6, 0x1)),
-    (0x1D6F1, (0x13BE, 0x1)),
-    (0x0FD6C, (0xD5C, 0x3)),
-    (0x0FB59, (0x9C2, 0x1)),
-    (0x0FEAA, (0xF48, 0x1)),
-    (0x0FE7E, (0xF0E, 0x2)),
-    (0x0315D, (0x468, 0x1)),
-    (0x02F7C, (0x3D5, 0x1)),
-    (0x1D7C4, (0x1491, 0x1)),
-    (0x02D6F, (0x356, 0x1)),
-    (0x1D653, (0x1322, 0x1)),
-    (0x0FE36, (0xEC0, 0x1)),
-    (0x0FEC3, (0xF61, 0x1)),
-    (0x03220, (0x51B, 0x3)),
-    (0x1D74F, (0x141C, 0x1)),
-    (0x02F63, (0x3BC, 0x1)),
-    (0x1D658, (0x1327, 0x1)),
-    (0x1D7CF, (0x149A, 0x1)),
-    (0x0FC04, (0xA7D, 0x3)),
-    (0x1D682, (0x1351, 0x1)),
-    (0x1D622, (0x12F1, 0x1)),
-    (0x033FA, (0x974, 0x3)),
-    (0x1D6EC, (0x13B9, 0x1)),
-    (0x01D5B, (0x0B4, 0x1)),
-    (0x0FCBA, (0xBFB, 0x2)),
-    (0x033F8, (0x96E, 0x3)),
-    (0x1D5BF, (0x128E, 0x1)),
-    (0x0FCA4, (0xBCF, 0x2)),
-    (0x1EEB4, (0x158E, 0x1)),
-    (0x1F217, (0x163F, 0x1)),
-    (0x01DA7, (0x0D1, 0x1)),
-    (0x1D736, (0x1403, 0x1)),
-    (0x1D720, (0x13ED, 0x1)),
-    (0x0FD94, (0xDCE, 0x3)),
-    (0x1D519, (0x11F0, 0x1)),
-    (0x1E03F, (0x14DA, 0x1)),
-    (0x1D7EF, (0x14BA, 0x1)),
-    (0x033A1, (0x892, 0x2)),
-    (0x1F143, (0x1616, 0x1)),
-    (0x1D4A5, (0x1186, 0x1)),
-    (0x02F9C, (0x3F5, 0x1)),
-    (0x0330B, (0x6B2, 0x3)),
-    (0x107A7, (0x10B0, 0x1)),
-    (0x0FF21, (0xFC9, 0x1)),
-    (0x02FC1, (0x41A, 0x1)),
-    (0x0FECA, (0xF68, 0x1)),
-    (0x1D63B, (0x130A, 0x1)),
-    (0x1F146, (0x1619, 0x1)),
-    (0x1CCF3, (0x10E0, 0x1)),
-    (0x1D633, (0x1302, 0x1)),
-    (0x024B9, (0x316, 0x1)),
-    (0x0334D, (0x7BA, 0x4)),
-    (0x032E9, (0x66E, 0x1)),
-    (0x033CF, (0x905, 0x2)),
-    (0x1D5E9, (0x12B8, 0x1)),
-    (0x024C0, (0x31D, 0x1)),
-    (0x1D64C, (0x131B, 0x1)),
-    (0x1D6C4, (0x1391, 0x1)),
-    (0x1E044, (0x14DF, 0x1)),
-    (0x1D407, (0x10EE, 0x1)),
-    (0x1D4AA, (0x1189, 0x1)),
-    (0x0328F, (0x5F0, 0x1)),
-    (0x1D529, (0x11FF, 0x1)),
-    (0x0249B, (0x2C2, 0x3)),
-    (0x03348, (0x7A6, 0x4)),
-    (0x02F08, (0x361, 0x1)),
-    (0x1D49E, (0x1183, 0x1)),
-    (0x03189, (0x494, 0x1)),
-    (0x1D42C, (0x1113, 0x1)),
-    (0x0207A, (0x149, 0x1)),
-    (0x1D6C5, (0x1392, 0x1)),
-    (0x02005, (0x118, 0x1)),
-    (0x1D5C2, (0x1291, 0x1)),
-    (0x0FB76, (0x9DF, 0x1)),
-    (0x1D6F9, (0x13C6, 0x1)),
-    (0x03147, (0x452, 0x1)),
-    (0x03184, (0x48F, 0x1)),
-    (0x02F92, (0x3EB, 0x1)),
-    (0x1D5D7, (0x12A6, 0x1)),
-    (0x0FB83, (0x9EC, 0x1)),
-    (0x02090, (0x15E, 0x1)),
-    (0x0FEA5, (0xF43, 0x1)),
-    (0x1D79D, (0x146A, 0x1)),
-    (0x1D7D9, (0x14A4, 0x1)),
-    (0x0FCC0, (0xC07, 0x2)),
-    (0x03279, (0x5D0, 0x2)),
-    (0x1D78F, (0x145C, 0x1)),
-    (0x0321D, (0x50E, 0x7)),
-    (0x1D6C7, (0x1394, 0x1)),
-    (0x1CCF5, (0x10E2, 0x1)),
-    (0x1EE8F, (0x1570, 0x1)),
-    (0x1EE0F, (0x1517, 0x1)),
-    (0x0FCDF, (0xC45, 0x3)),
-    (0x1D501, (0x11DC, 0x1)),
-    (0x1D610, (0x12DF, 0x1)),
-    (0x1CCE0, (0x10CD, 0x1)),
-    (0x0FD21, (0xCCE, 0x2)),
-    (0x032E4, (0x669, 0x1)),
-    (0x1F13D, (0x1610, 0x1)),
-    (0x0FCF7, (0xC7A, 0x2)),
-    (0x0313D, (0x448, 0x1)),
-    (0x01D9D, (0x0C7, 0x1)),
-    (0x02474, (0x24B, 0x3)),
-    (0x0FFBD, (0x1065, 0x1)),
-    (0x1D7D0, (0x149B, 0x1)),
-    (0x1F232, (0x165A, 0x1)),
-    (0x1F225, (0x164D, 0x1)),
-    (0x1D7F1, (0x14BC, 0x1)),
-    (0x03232, (0x551, 0x3)),
-    (0x0249E, (0x2CB, 0x3)),
-    (0x02F75, (0x3CE, 0x1)),
-    (0x1F210, (0x1637, 0x1)),
-    (0x1D4D5, (0x11B0, 0x1)),
-    (0x03222, (0x521, 0x3)),
-    (0x1D782, (0x144F, 0x1)),
-    (0x10789, (0x1092, 0x1)),
-    (0x03305, (0x69C, 0x3)),
-    (0x0FF4B, (0xFF3, 0x1)),
-    (0x0FCB2, (0xBEB, 0x2)),
-    (0x03199, (0x4A1, 0x1)),
-    (0x0FEEA, (0xF88, 0x1)),
-    (0x03396, (0x87A, 0x2)),
-    (0x03247, (0x58A, 0x1)),
-    (0x0FC88, (0xB92, 0x2)),
-    (0x0FBA6, (0xA11, 0x1)),
-    (0x01D9C, (0x0C6, 0x1)),
-    (0x0FC82, (0xB86, 0x2)),
-    (0x1EE6A, (0x1551, 0x1)),
-    (0x0FD38, (0xCFC, 0x2)),
-    (0x03325, (0x720, 0x3)),
-    (0x1D6BF, (0x138C, 0x1)),
-    (0x1D4B4, (0x1192, 0x1)),
-    (0x1D6CA, (0x1397, 0x1)),
-    (0x0339E, (0x88A, 0x2)),
-    (0x1D641, (0x1310, 0x1)),
-    (0x0FE63, (0xEEE, 0x1)),
-    (0x024D0, (0x32D, 0x1)),
-    (0x0FC9B, (0xBBC, 0x3)),
-    (0x0FE8D, (0xF2B, 0x1)),
-    (0x01DA5, (0x0CF, 0x1)),
-    (0x0A7F9, (0x98D, 0x1)),
-    (0x1D43B, (0x1122, 0x1)),
-    (0x0FDBA, (0xE40, 0x3)),
-    (0x1F134, (0x1607, 0x1)),
-    (0x0FC77, (0xB70, 0x2)),
-    (0x02FB0, (0x409, 0x1)),
-    (0x1D426, (0x110D, 0x1)),
-    (0x1D453, (0x113A, 0x1)),
-    (0x1D5DC, (0x12AB, 0x1)),
-    (0x1D6F3, (0x13C0, 0x1)),
-    (0x1D5EC, (0x12BB, 0x1)),
-    (0x024C5, (0x322, 0x1)),
-    (0x03168, (0x473, 0x1)),
-    (0x1D6CF, (0x139C, 0x1)),
-    (0x024B0, (0x301, 0x3)),
-    (0x1D568, (0x1237, 0x1)),
-    (0x1F122, (0x15E2, 0x3)),
-    (0x1D52E, (0x1204, 0x1)),
-    (0x1D511, (0x11E9, 0x1)),
-    (0x02FB1, (0x40A, 0x1)),
-    (0x1F137, (0x160A, 0x1)),
-    (0x0FFAA, (0x1052, 0x1)),
-    (0x0FB69, (0x9D2, 0x1)),
-    (0x01FCF, (0x0FD, 0x3)),
-    (0x1D5AA, (0x1279, 0x1)),
-    (0x1D6F6, (0x13C3, 0x1)),
-    (0x1D4EC, (0x11C7, 0x1)),
-    (0x1D5CF, (0x129E, 0x1)),
-    (0x032A4, (0x605, 0x1)),
-    (0x033CE, (0x903, 0x2)),
-    (0x10781, (0x108B, 0x1)),
-    (0x02F6F, (0x3C8, 0x1)),
-    (0x1F126, (0x15EE, 0x3)),
-    (0x02F5A, (0x3B3, 0x1)),
-    (0x0FF68, (0x1010, 0x1)),
-    (0x02F88, (0x3E1, 0x1)),
-    (0x01DB0, (0x0DA, 0x1)),
-    (0x0FCD0, (0xC27, 0x2)),
-    (0x033B0, (0x8C2, 0x2)),
-    (0x0333D, (0x77E, 0x5)),
-    (0x1E069, (0x1504, 0x1)),
-    (0x0FF8D, (0x1035, 0x1)),
-    (0x1D70C, (0x13D9, 0x1)),
-    (0x1D643, (0x1312, 0x1)),
-    (0x0FBA0, (0xA09, 0x1)),
-    (0x03157, (0x462, 0x1)),
-    (0x1D457, (0x113D, 0x1)),
-    (0x0FE95, (0xF33, 0x1)),
-    (0x0FD83, (0xDA1, 0x3)),
-    (0x1D56F, (0x123E, 0x1)),
-    (0x02F16, (0x36F, 0x1)),
-    (0x1D731, (0x13FE, 0x1)),
-    (0x1D459, (0x113F, 0x1)),
-    (0x1D698, (0x1367, 0x1)),
-    (0x1D740, (0x140D, 0x1)),
-    (0x033F5, (0x965, 0x3)),
-    (0x0339D, (0x888, 0x2)),
-    (0x03224, (0x527, 0x3)),
-    (0x0FC1C, (0xAAE, 0x2)),
-    (0x1F116, (0x15BE, 0x3)),
-    (0x0213F, (0x1AC, 0x1)),
-    (0x0FC39, (0xAE8, 0x2)),
-    (0x0FF2C, (0xFD4, 0x1)),
-    (0x1D5C7, (0x1296, 0x1)),
-    (0x03377, (0x831, 0x2)),
-    (0x1D788, (0x1455, 0x1)),
-    (0x02FD5, (0x42E, 0x1)),
-    (0x1D75E, (0x142B, 0x1)),
-    (0x1D743, (0x1410, 0x1)),
-    (0x0320B, (0x4C9, 0x3)),
-    (0x1F238, (0x1660, 0x1)),
-    (0x033A2, (0x894, 0x3)),
-    (0x0FE78, (0xF02, 0x2)),
-    (0x0FE93, (0xF31, 0x1)),
-    (0x1D683, (0x1352, 0x1)),
-    (0x0FD64, (0xD44, 0x3)),
-    (0x1D634, (0x1303, 0x1)),
-    (0x0FF3B, (0xFE3, 0x1)),
-    (0x01D9E, (0x0C8, 0x1)),
-    (0x03327, (0x726, 0x2)),
-    (0x1F236, (0x165E, 0x1)),
-    (0x1D5C0, (0x128F, 0x1)),
-    (0x02FCC, (0x425, 0x1)),
-    (0x1D431, (0x1118, 0x1)),
-    (0x1EE0B, (0x1513, 0x1)),
-    (0x1D7BA, (0x1487, 0x1)),
-    (0x0FC48, (0xB06, 0x2)),
-    (0x0FEF3, (0xF91, 0x1)),
-    (0x1D4CE, (0x11A9, 0x1)),
-    (0x0FFC3, (0x1068, 0x1)),
-    (0x1D4FD, (0x11D8, 0x1)),
-    (0x0FC1B, (0xAAC, 0x2)),
-    (0x1EE8C, (0x156D, 0x1)),
-    (0x1D784, (0x1451, 0x1)),
-    (0x03264, (0x5B0, 0x1)),
-    (0x0FF7B, (0x1023, 0x1)),
-    (0x1EE59, (0x1547, 0x1)),
-    (0x1D790, (0x145D, 0x1)),
-    (0x02F31, (0x38A, 0x1)),
-    (0x0FF22, (0xFCA, 0x1)),
-    (0x0211D, (0x190, 0x1)),
-    (0x1E057, (0x14F2, 0x1)),
-    (0x1D6FE, (0x13CB, 0x1)),
-    (0x1D484, (0x116A, 0x1)),
-    (0x1D668, (0x1337, 0x1)),
-    (0x0FE5F, (0xEEA, 0x1)),
-    (0x1D562, (0x1231, 0x1)),
-    (0x0319F, (0x4A7, 0x1)),
-    (0x02074, (0x143, 0x1)),
-    (0x1D5EF, (0x12BE, 0x1)),
-    (0x107AB, (0x10B4, 0x1)),
-    (0x020A8, (0x16B, 0x2)),
-    (0x1E063, (0x14FE, 0x1)),
-    (0x0FC57, (0xB24, 0x2)),
-    (0x03356, (0x7D9, 0x6)),
-    (0x1D43D, (0x1124, 0x1)),
-    (0x0FCCF, (0xC25, 0x2)),
-    (0x01D47, (0x0A1, 0x1)),
-    (0x1D654, (0x1323, 0x1)),
-    (0x0FFE8, (0x1084, 0x1)),
-    (0x03302, (0x68F, 0x5)),
-    (0x0FCD9, (0xC39, 0x2)),
-    (0x1D639, (0x1308, 0x1)),
-    (0x1D79F, (0x146C, 0x1)),
-    (0x1D6B2, (0x137F, 0x1)),
-    (0x0FE8E, (0xF2C, 0x1)),
-    (0x1E048, (0x14E3, 0x1)),
-    (0x03039, (0x432, 0x1)),
-    (0x1E064, (0x14FF, 0x1)),
-    (0x033A0, (0x88F, 0x3)),
-    (0x1D49F, (0x1184, 0x1)),
-    (0x02F4C, (0x3A5, 0x1)),
-    (0x0FC31, (0xAD8, 0x2)),
-    (0x1D491, (0x1177, 0x1)),
-    (0x1E04D, (0x14E8, 0x1)),
-    (0x0FF16, (0xFBE, 0x1)),
-    (0x01D68, (0x0C1, 0x1)),
-    (0x0FF71, (0x1019, 0x1)),
-    (0x1EE76, (0x155B, 0x1)),
-    (0x1D423, (0x110A, 0x1)),
-    (0x01FCD, (0x0F7, 0x3)),
-    (0x0FE44, (0xECE, 0x1)),
-    (0x1F132, (0x1605, 0x1)),
-    (0x1D77C, (0x1449, 0x1)),
-    (0x0FF93, (0x103B, 0x1)),
-    (0x0331B, (0x6FA, 0x4)),
-    (0x1D7F5, (0x14C0, 0x1)),
-    (0x0FF8F, (0x1037, 0x1)),
-    (0x032A2, (0x603, 0x1)),
-    (0x1EE0E, (0x1516, 0x1)),
-    (0x1D6E8, (0x13B5, 0x1)),
-    (0x1D520, (0x11F6, 0x1)),
-    (0x033E4, (0x937, 0x2)),
-    (0x1D44E, (0x1135, 0x1)),
-    (0x1CCD9, (0x10C6, 0x1)),
-    (0x02FC4, (0x41D, 0x1)),
-    (0x02024, (0x121, 0x1)),
-    (0x010FC, (0x087, 0x1)),
-    (0x0FDB0, (0xE22, 0x3)),
-    (0x1EE87, (0x1569, 0x1)),
-    (0x03000, (0x42F, 0x1)),
-    (0x1FBF6, (0x1687, 0x1)),
-    (0x1D76F, (0x143C, 0x1)),
-    (0x03385, (0x851, 0x2)),
-    (0x0325D, (0x5A6, 0x2)),
-    (0x1D6C3, (0x1390, 0x1)),
-    (0x0FC0A, (0xA8A, 0x2)),
-    (0x1D67C, (0x134B, 0x1)),
-    (0x0FF9B, (0x1043, 0x1)),
-    (0x0FE7A, (0xF06, 0x2)),
-    (0x02FB4, (0x40D, 0x1)),
-    (0x02096, (0x164, 0x1)),
-    (0x0247C, (0x263, 0x3)),
-    (0x1D64A, (0x1319, 0x1)),
-    (0x1D785, (0x1452, 0x1)),
-    (0x1D7DA, (0x14A5, 0x1)),
-    (0x0FB17, (0x9AB, 0x2)),
-    (0x1D761, (0x142E, 0x1)),
-    (0x032C7, (0x63E, 0x2)),
-    (0x01FC0, (0x0F2, 0x2)),
-    (0x033E3, (0x935, 0x2)),
-    (0x0FCDB, (0xC3D, 0x2)),
-    (0x1D5B4, (0x1283, 0x1)),
-    (0x1D48F, (0x1175, 0x1)),
-    (0x0FC2A, (0xACA, 0x2)),
-    (0x1D55B, (0x122A, 0x1)),
-    (0x1D68A, (0x1359, 0x1)),
-    (0x1D637, (0x1306, 0x1)),
-    (0x0FFB6, (0x105E, 0x1)),
-    (0x1D770, (0x143D, 0x1)),
-    (0x107A4, (0x10AD, 0x1)),
-    (0x03186, (0x491, 0x1)),
-    (0x0FE18, (0xEB5, 0x1)),
-    (0x03253, (0x592, 0x2)),
-    (0x02163, (0x1E9, 0x2)),
-    (0x02F51, (0x3AA, 0x1)),
-    (0x003F5, (0x06C, 0x1)),
-    (0x0329B, (0x5FC, 0x1)),
-    (0x0FFB8, (0x1060, 0x1)),
-    (0x03215, (0x4EE, 0x4)),
-    (0x0FFA3, (0x104B, 0x1)),
-    (0x1D4CA, (0x11A5, 0x1)),
-    (0x0FBAB, (0xA16, 0x1)),
-    (0x0FF65, (0x100D, 0x1)),
-    (0x0FE5C, (0xEE7, 0x1)),
-    (0x0FC52, (0xB1A, 0x2)),
-    (0x02F9B, (0x3F4, 0x1)),
-    (0x1D51A, (0x11F1, 0x1)),
-    (0x03234, (0x557, 0x3)),
-    (0x00E33, (0x078, 0x2)),
-    (0x0FD8A, (0xDB6, 0x3)),
-    (0x0FD5A, (0xD26, 0x3)),
-    (0x02494, (0x2AD, 0x3)),
-    (0x02F80, (0x3D9, 0x1)),
-    (0x0FB67, (0x9D0, 0x1)),
-    (0x032A1, (0x602, 0x1)),
-    (0x1D797, (0x1464, 0x1)),
-    (0x0309C, (0x436, 0x2)),
-    (0x0FFE1, (0x107D, 0x1)),
-    (0x0FD7B, (0xD89, 0x3)),
-    (0x0FB61, (0x9CA, 0x1)),
-    (0x0FF10, (0xFB8, 0x1)),
-    (0x03280, (0x5E1, 0x1)),
-    (0x1F138, (0x160B, 0x1)),
-    (0x033AE, (0x8B7, 0x5)),
-    (0x10798, (0x10A1, 0x1)),
-    (0x1D738, (0x1405, 0x1)),
-    (0x0FC5D, (0xB30, 0x2)),
-    (0x1D50E, (0x11E6, 0x1)),
-    (0x02F4B, (0x3A4, 0x1)),
-    (0x02FA4, (0x3FD, 0x1)),
-    (0x032B6, (0x61C, 0x2)),
-    (0x032EB, (0x670, 0x1)),
-    (0x03135, (0x440, 0x1)),
-    (0x1D5C3, (0x1292, 0x1)),
-    (0x0FB97, (0xA00, 0x1)),
-    (0x0FCE8, (0xC59, 0x2)),
-    (0x0322B, (0x53C, 0x3)),
-    (0x0FC43, (0xAFC, 0x2)),
-    (0x032E5, (0x66A, 0x1)),
-    (0x0FBA5, (0xA0F, 0x2)),
-    (0x1D6EE, (0x13BB, 0x1)),
-    (0x0FD80, (0xD98, 0x3)),
-    (0x01DAC, (0x0D6, 0x1)),
-    (0x1CCDF, (0x10CC, 0x1)),
-    (0x1E03C, (0x14D7, 0x1)),
-    (0x02037, (0x12F, 0x3)),
-    (0x1D5F8, (0x12C7, 0x1)),
-    (0x1D66C, (0x133B, 0x1)),
-    (0x03150, (0x45B, 0x1)),
-    (0x03276, (0x5CA, 0x2)),
-    (0x1D4EA, (0x11C5, 0x1)),
-    (0x032BC, (0x628, 0x2)),
-    (0x1F145, (0x1618, 0x1)),
-    (0x0213E, (0x1AB, 0x1)),
-    (0x1D412, (0x10F9, 0x1)),
-    (0x10790, (0x1099, 0x1)),
-    (0x0FEDA, (0xF78, 0x1)),
-    (0x1F12E, (0x1601, 0x2)),
-    (0x1D4F1, (0x11CC, 0x1)),
-    (0x0FED2, (0xF70, 0x1)),
-    (0x0FD81, (0xD9B, 0x3)),
-    (0x03306, (0x69F, 0x3)),
-    (0x02473, (0x249, 0x2)),
-    (0x1D6B0, (0x137D, 0x1)),
-    (0x0FB9F, (0xA08, 0x1)),
-    (0x033B4, (0x8CA, 0x2)),
-    (0x03214, (0x4EA, 0x4)),
-    (0x1D7E2, (0x14AD, 0x1)),
-    (0x0331D, (0x701, 0x3)),
-    (0x1D578, (0x1247, 0x1)),
-    (0x02122, (0x196, 0x2)),
-    (0x0FF44, (0xFEC, 0x1)),
-    (0x1D4F7, (0x11D2, 0x1)),
-    (0x0FCD3, (0xC2D, 0x2)),
-    (0x0FFCA, (0x106D, 0x1)),
-    (0x000B5, (0x00A, 0x1)),
-    (0x0FC32, (0xADA, 0x2)),
-    (0x1D7C5, (0x1492, 0x1)),
-    (0x1D625, (0x12F4, 0x1)),
-    (0x032A3, (0x604, 0x1)),
-    (0x03311, (0x6C9, 0x4)),
-    (0x1EE2C, (0x152F, 0x1)),
-    (0x03180, (0x48B, 0x1)),
-    (0x0FB5D, (0x9C6, 0x1)),
-    (0x0FB25, (0x9B2, 0x1)),
-    (0x0FBEE, (0xA43, 0x3)),
-    (0x02FC7, (0x420, 0x1)),
-    (0x0322F, (0x548, 0x3)),
-    (0x1D5FE, (0x12CD, 0x1)),
-    (0x02F36, (0x38F, 0x1)),
-    (0x1D74D, (0x141A, 0x1)),
-    (0x1D5A5, (0x1274, 0x1)),
-    (0x02FC3, (0x41C, 0x1)),
-    (0x1E06C, (0x1507, 0x1)),
-    (0x1D508, (0x11E2, 0x1)),
-    (0x1D741, (0x140E, 0x1)),
-    (0x03221, (0x51E, 0x3)),
-    (0x1D512, (0x11EA, 0x1)),
-    (0x0FECE, (0xF6C, 0x1)),
-    (0x1D6D5, (0x13A2, 0x1)),
-    (0x032A7, (0x608, 0x1)),
-    (0x1D6B8, (0x1385, 0x1)),
-    (0x0FF06, (0xFAE, 0x1)),
-    (0x0FFE5, (0x1082, 0x1)),
-    (0x0323C, (0x56F, 0x3)),
-    (0x1CCE1, (0x10CE, 0x1)),
-    (0x0FE39, (0xEC3, 0x1)),
-    (0x0FBFC, (0xA6D, 0x1)),
-    (0x1F11D, (0x15D3, 0x3)),
-    (0x0FCCD, (0xC21, 0x2)),
-    (0x0FF42, (0xFEA, 0x1)),
-    (0x02189, (0x21F, 0x3)),
-    (0x00149, (0x020, 0x2)),
-    (0x01DB3, (0x0DD, 0x1)),
-    (0x1EE4D, (0x1540, 0x1)),
-    (0x1D6E7, (0x13B4, 0x1)),
-    (0x107A0, (0x10A9, 0x1)),
-    (0x002DD, (0x051, 0x2)),
-    (0x02F97, (0x3F0, 0x1)),
-    (0x1D71E, (0x13EB, 0x1)),
-    (0x1D4F9, (0x11D4, 0x1)),
-    (0x02102, (0x173, 0x1)),
-    (0x1D7B4, (0x1481, 0x1)),
-    (0x0315B, (0x466, 0x1)),
-    (0x0AB5D, (0x98F, 0x1)),
-    (0x001CB, (0x034, 0x2)),
-    (0x0FED9, (0xF77, 0x1)),
-    (0x02167, (0x1F1, 0x4)),
-    (0x0FD20, (0xCCC, 0x2)),
-    (0x1D69D, (0x136C, 0x1)),
-    (0x1D561, (0x1230, 0x1)),
-    (0x0213D, (0x1AA, 0x1)),
-    (0x1D7F4, (0x14BF, 0x1)),
-    (0x1D632, (0x1301, 0x1)),
-    (0x0FF9A, (0x1042, 0x1)),
-    (0x03389, (0x85A, 0x4)),
-    (0x02034, (0x12A, 0x3)),
-    (0x01D67, (0x0C0, 0x1)),
-    (0x0FF23, (0xFCB, 0x1)),
-    (0x1D577, (0x1246, 0x1)),
-    (0x0FEDC, (0xF7A, 0x1)),
-    (0x1D75B, (0x1428, 0x1)),
-    (0x1D4B9, (0x1197, 0x1)),
-    (0x033BA, (0x8D6, 0x2)),
-    (0x1D667, (0x1336, 0x1)),
-    (0x0331C, (0x6FE, 0x3)),
-    (0x1CCD7, (0x10C4, 0x1)),
-    (0x0FEC7, (0xF65, 0x1)),
-    (0x1CCF6, (0x10E3, 0x1)),
-    (0x1EE99, (0x157A, 0x1)),
-    (0x1CCEE, (0x10DB, 0x1)),
-    (0x1D5DA, (0x12A9, 0x1)),
-    (0x1D454, (0x113B, 0x1)),
-    (0x1EE94, (0x1575, 0x1)),
-    (0x1D4FC, (0x11D7, 0x1)),
-    (0x1D7A5, (0x1472, 0x1)),
-    (0x1F120, (0x15DC, 0x3)),
-    (0x1D72C, (0x13F9, 0x1)),
-    (0x0FE52, (0xEDE, 0x1)),
-    (0x1D684, (0x1353, 0x1)),
-    (0x0FE86, (0xF1D, 0x2)),
-    (0x03360, (0x7F2, 0x2)),
-    (0x02F0F, (0x368, 0x1)),
-    (0x1D5CE, (0x129D, 0x1)),
-    (0x1D60B, (0x12DA, 0x1)),
-    (0x1D5BA, (0x1289, 0x1)),
-    (0x02F10, (0x369, 0x1)),
-    (0x1D726, (0x13F3, 0x1)),
-    (0x0FFEB, (0x1087, 0x1)),
-    (0x02491, (0x2A4, 0x3)),
-    (0x0FE16, (0xEB3, 0x1)),
-    (0x1D754, (0x1421, 0x1)),
-    (0x032AD, (0x60E, 0x1)),
-    (0x02116, (0x18A, 0x2)),
-    (0x1D6CE, (0x139B, 0x1)),
-    (0x1D71D, (0x13EA, 0x1)),
-    (0x0FEA8, (0xF46, 0x1)),
-    (0x1D434, (0x111B, 0x1)),
-    (0x1D483, (0x1169, 0x1)),
-    (0x1D443, (0x112A, 0x1)),
-    (0x0FF1C, (0xFC4, 0x1)),
-    (0x0210A, (0x17F, 0x1)),
-    (0x1D6C1, (0x138E, 0x1)),
-    (0x1E040, (0x14DB, 0x1)),
-    (0x02F41, (0x39A, 0x1)),
-    (0x01DBD, (0x0E7, 0x1)),
-    (0x0FC2B, (0xACC, 0x2)),
-    (0x032CA, (0x645, 0x3)),
-    (0x03321, (0x711, 0x5)),
-    (0x03364, (0x7FC, 0x3)),
-    (0x1F130, (0x1603, 0x1)),
-    (0x02FBE, (0x417, 0x1)),
-    (0x0FE68, (0xEF2, 0x1)),
-    (0x0FCC4, (0xC0F, 0x2)),
-    (0x1D719, (0x13E6, 0x1)),
-    (0x1D5C8, (0x1297, 0x1)),
-    (0x1D4DC, (0x11B7, 0x1)),
-    (0x1D537, (0x120D, 0x1)),
-    (0x0FD3A, (0xD00, 0x2)),
-    (0x01D64, (0x0BD, 0x1)),
-    (0x0315E, (0x469, 0x1)),
-    (0x1EE19, (0x1521, 0x1)),
-    (0x0FF01, (0xFA9, 0x1)),
-    (0x1EE3B, (0x153B, 0x1)),
-    (0x1D4FE, (0x11D9, 0x1)),
-    (0x01FBF, (0x0F0, 0x2)),
-    (0x0216E, (0x1FF, 0x1)),
-    (0x1D5B3, (0x1282, 0x1)),
-    (0x01D44, (0x09E, 0x1)),
-    (0x032CD, (0x64D, 0x3)),
-    (0x01D42, (0x09C, 0x1)),
-    (0x1D56E, (0x123D, 0x1)),
-    (0x033DF, (0x92C, 0x3)),
-    (0x0FFB5, (0x105D, 0x1)),
-    (0x1E042, (0x14DD, 0x1)),
-    (0x02F81, (0x3DA, 0x1)),
-    (0x0FB6B, (0x9D4, 0x1)),
-    (0x0FCBF, (0xC05, 0x2)),
-    (0x0FD58, (0xD20, 0x3)),
-    (0x1D64E, (0x131D, 0x1)),
-    (0x0FEFC, (0xFA7, 0x2)),
-    (0x03246, (0x589, 0x1)),
-    (0x03162, (0x46D, 0x1)),
-    (0x02F65, (0x3BE, 0x1)),
-    (0x0FD96, (0xDD4, 0x3)),
-    (0x1D5E7, (0x12B6, 0x1)),
-    (0x03273, (0x5C4, 0x2)),
-    (0x0FCCE, (0xC23, 0x2)),
-    (0x003D5, (0x066, 0x1)),
-    (0x0326B, (0x5B7, 0x1)),
-    (0x032D0, (0x655, 0x1)),
-    (0x0FFE9, (0x1085, 0x1)),
-    (0x1D5D5, (0x12A4, 0x1)),
-    (0x1F21F, (0x1647, 0x1)),
-    (0x0FB8B, (0x9F4, 0x1)),
-    (0x0FEE0, (0xF7E, 0x1)),
-    (0x02F99, (0x3F2, 0x1)),
-    (0x02FA3, (0x3FC, 0x1)),
-    (0x0FBF5, (0xA58, 0x3)),
-    (0x1D43C, (0x1123, 0x1)),
-    (0x1D7B6, (0x1483, 0x1)),
-    (0x0FBE0, (0xA2D, 0x1)),
-    (0x1D40D, (0x10F4, 0x1)),
-    (0x1F144, (0x1617, 0x1)),
-    (0x03165, (0x470, 0x1)),
-    (0x0323D, (0x572, 0x3)),
-    (0x1D46C, (0x1152, 0x1)),
-    (0x1D4AE, (0x118C, 0x1)),
-    (0x02085, (0x154, 0x1)),
-    (0x02F86, (0x3DF, 0x1)),
-    (0x1EE95, (0x1576, 0x1)),
-    (0x0FDA8, (0xE0A, 0x3)),
-    (0x03228, (0x533, 0x3)),
-    (0x03213, (0x4E6, 0x4)),
-    (0x02485, (0x286, 0x4)),
-    (0x1D70A, (0x13D7, 0x1)),
-    (0x02F57, (0x3B0, 0x1)),
-    (0x1F14E, (0x1625, 0x3)),
-    (0x0FB96, (0x9FF, 0x1)),
-    (0x0FCE5, (0xC53, 0x2)),
-    (0x0317A, (0x485, 0x1)),
-    (0x03294, (0x5F5, 0x1)),
-    (0x1D786, (0x1453, 0x1)),
-    (0x024E4, (0x341, 0x1)),
-    (0x02495, (0x2B0, 0x3)),
-    (0x1F124, (0x15E8, 0x3)),
-    (0x03272, (0x5C2, 0x2)),
-    (0x02F9A, (0x3F3, 0x1)),
-    (0x0FD61, (0xD3B, 0x3)),
-    (0x0FCB0, (0xBE7, 0x2)),
-    (0x0FD02, (0xC90, 0x2)),
-    (0x1EEAB, (0x1585, 0x1)),
-    (0x1079F, (0x10A8, 0x1)),
-    (0x1D5AE, (0x127D, 0x1)),
-    (0x1D7B1, (0x147E, 0x1)),
-    (0x024C3, (0x320, 0x1)),
-    (0x0FC8E, (0xB9E, 0x2)),
-    (0x1D5E0, (0x12AF, 0x1)),
-    (0x0FFA9, (0x1051, 0x1)),
-    (0x01D33, (0x08E, 0x1)),
-    (0x1D505, (0x11E0, 0x1)),
-    (0x1D767, (0x1434, 0x1)),
-    (0x1D53D, (0x1212, 0x1)),
-    (0x1078F, (0x1098, 0x1)),
-    (0x0FC3F, (0xAF4, 0x2)),
-    (0x1D6A9, (0x1376, 0x1)),
-    (0x1D47A, (0x1160, 0x1)),
-    (0x0FC72, (0xB66, 0x2)),
-    (0x03151, (0x45C, 0x1)),
-    (0x03335, (0x75F, 0x3)),
-    (0x1D579, (0x1248, 0x1)),
-    (0x02F72, (0x3CB, 0x1)),
-    (0x0222F, (0x227, 0x2)),
-    (0x000BA, (0x00E, 0x1)),
-    (0x1D6BB, (0x1388, 0x1)),
-    (0x0FF03, (0xFAB, 0x1)),
-    (0x033B6, (0x8CE, 0x2)),
-    (0x1D419, (0x1100, 0x1)),
-    (0x1D763, (0x1430, 0x1)),
-    (0x02171, (0x202, 0x2)),
-    (0x02017, (0x11F, 0x2)),
-    (0x032B5, (0x61A, 0x2)),
-    (0x00132, (0x018, 0x2)),
-    (0x1EE8D, (0x156E, 0x1)),
-    (0x0319B, (0x4A3, 0x1)),
-    (0x1D5ED, (0x12BC, 0x1)),
-    (0x0FF58, (0x1000, 0x1)),
-    (0x0313C, (0x447, 0x1)),
-    (0x0FB7D, (0x9E6, 0x1)),
-    (0x03394, (0x875, 0x3)),
-    (0x02124, (0x198, 0x1)),
-    (0x02F50, (0x3A9, 0x1)),
-    (0x1D522, (0x11F8, 0x1)),
-    (0x0FF66, (0x100E, 0x1)),
-    (0x0FDFA, (0xE8F, 0x12)),
-    (0x0FC71, (0xB64, 0x2)),
-    (0x1D772, (0x143F, 0x1)),
-    (0x1D65A, (0x1329, 0x1)),
-    (0x1D7C6, (0x1493, 0x1)),
-    (0x0FEB8, (0xF56, 0x1)),
-    (0x0FEEE, (0xF8C, 0x1)),
-    (0x1EE61, (0x154B, 0x1)),
-    (0x0FB68, (0x9D1, 0x1)),
-    (0x1F103, (0x159C, 0x2)),
-    (0x1D585, (0x1254, 0x1)),
-    (0x03352, (0x7CC, 0x2)),
-    (0x0FDF2, (0xE70, 0x4)),
-    (0x0331A, (0x6F4, 0x6)),
-    (0x1D52C, (0x1202, 0x1)),
-    (0x0013F, (0x01C, 0x2)),
-    (0x02FAF, (0x408, 0x1)),
-    (0x032C1, (0x632, 0x2)),
-    (0x03320, (0x70C, 0x5)),
-    (0x1D5FD, (0x12CC, 0x1)),
-    (0x0FEB7, (0xF55, 0x1)),
-    (0x0FFE6, (0x1083, 0x1)),
-    (0x0FCE9, (0xC5B, 0x2)),
-    (0x0FD7A, (0xD86, 0x3)),
-    (0x0FF87, (0x102F, 0x1)),
-    (0x1EE1A, (0x1522, 0x1)),
-    (0x1F248, (0x167C, 0x3)),
-    (0x1D7C2, (0x148F, 0x1)),
-    (0x1D694, (0x1363, 0x1)),
-    (0x033B5, (0x8CC, 0x2)),
-    (0x03245, (0x588, 0x1)),
-    (0x1EE27, (0x152B, 0x1)),
-    (0x0FDBE, (0xE4C, 0x3)),
-    (0x1EE91, (0x1572, 0x1)),
-    (0x03329, (0x72A, 0x3)),
-    (0x1D4CF, (0x11AA, 0x1)),
-    (0x0FED3, (0xF71, 0x1)),
-    (0x02134, (0x1A0, 0x1)),
-    (0x03287, (0x5E8, 0x1)),
-    (0x024AE, (0x2FB, 0x3)),
-    (0x0FEB9, (0xF57, 0x1)),
-    (0x032AB, (0x60C, 0x1)),
-    (0x1D596, (0x1265, 0x1)),
-    (0x1D4F8, (0x11D3, 0x1)),
-    (0x0FEC9, (0xF67, 0x1)),
-    (0x1F22C, (0x1654, 0x1)),
-    (0x1F13A, (0x160D, 0x1)),
-    (0x032EF, (0x674, 0x1)),
-    (0x1D77F, (0x144C, 0x1)),
-    (0x02F82, (0x3DB, 0x1)),
-    (0x1D6E1, (0x13AE, 0x1)),
-    (0x03314, (0x6D7, 0x2)),
-    (0x0FEA4, (0xF42, 0x1)),
-    (0x1F115, (0x15BB, 0x3)),
-    (0x0222D, (0x224, 0x3)),
-    (0x1D4C9, (0x11A4, 0x1)),
-    (0x1D567, (0x1236, 0x1)),
-    (0x1D7EE, (0x14B9, 0x1)),
-    (0x032F1, (0x676, 0x1)),
-    (0x0FF8C, (0x1034, 0x1)),
-    (0x1D5A6, (0x1275, 0x1)),
-    (0x0FE61, (0xEEC, 0x1)),
-    (0x033EF, (0x953, 0x3)),
-    (0x02140, (0x1AD, 0x1)),
-    (0x1D659, (0x1328, 0x1)),
-    (0x1D542, (0x1216, 0x1)),
-    (0x03137, (0x442, 0x1)),
-    (0x02F2D, (0x386, 0x1)),
-    (0x1D4EE, (0x11C9, 0x1)),
-    (0x0FFE0, (0x107C, 0x1)),
-    (0x1D4E0, (0x11BB, 0x1)),
-    (0x01D34, (0x08F, 0x1)),
-    (0x1D6ED, (0x13BA, 0x1)),
-    (0x01DAD, (0x0D7, 0x1)),
-    (0x1D766, (0x1433, 0x1)),
-    (0x03380, (0x847, 0x2)),
-    (0x02170, (0x201, 0x1)),
-    (0x0FE35, (0xEBF, 0x1)),
-    (0x033A8, (0x8A5, 0x4)),
-    (0x1D650, (0x131F, 0x1)),
-    (0x01DB2, (0x0DC, 0x1)),
-    (0x1D4DD, (0x11B8, 0x1)),
-    (0x1F222, (0x164A, 0x1)),
-    (0x00587, (0x06E, 0x2)),
-    (0x02080, (0x14F, 0x1)),
-    (0x0FC8A, (0xB96, 0x2)),
-    (0x1D71C, (0x13E9, 0x1)),
-    (0x1D52A, (0x1200, 0x1)),
-    (0x1D557, (0x1226, 0x1)),
-    (0x0A69C, (0x986, 0x1)),
-    (0x0FD66, (0xD4A, 0x3)),
-    (0x02A74, (0x34C, 0x3)),
-    (0x1D764, (0x1431, 0x1)),
-    (0x1D45D, (0x1143, 0x1)),
-    (0x0FCBE, (0xC03, 0x2)),
-    (0x1D7F0, (0x14BB, 0x1)),
-    (0x0FBEA, (0xA37, 0x3)),
-    (0x02036, (0x12D, 0x2)),
-    (0x01FBD, (0x0EE, 0x2)),
-    (0x1D527, (0x11FD, 0x1)),
-    (0x1D5FB, (0x12CA, 0x1)),
-    (0x0FD57, (0xD1D, 0x3)),
-    (0x0318B, (0x496, 0x1)),
-    (0x0FDF5, (0xE7C, 0x4)),
-    (0x1078C, (0x1095, 0x1)),
-    (0x1CCF9, (0x10E6, 0x1)),
-    (0x1EEB6, (0x1590, 0x1)),
-    (0x1D6E3, (0x13B0, 0x1)),
-    (0x03166, (0x471, 0x1)),
-    (0x0338A, (0x85E, 0x2)),
-    (0x1D5EE, (0x12BD, 0x1)),
-    (0x03241, (0x57E, 0x3)),
-    (0x03365, (0x7FF, 0x3)),
-    (0x0FD39, (0xCFE, 0x2)),
-    (0x1EE17, (0x151F, 0x1)),
-    (0x1D432, (0x1119, 0x1)),
-    (0x1D56A, (0x1239, 0x1)),
-    (0x1D606, (0x12D5, 0x1)),
-    (0x0FEDD, (0xF7B, 0x1)),
-    (0x0FE64, (0xEEF, 0x1)),
-    (0x1D496, (0x117C, 0x1)),
-    (0x1CCEB, (0x10D8, 0x1)),
-    (0x1D7FA, (0x14C5, 0x1)),
-    (0x1D4BB, (0x1198, 0x1)),
-    (0x1D75C, (0x1429, 0x1)),
-    (0x001C9, (0x030, 0x2)),
-    (0x1FBF3, (0x1684, 0x1)),
-    (0x01D45, (0x09F, 0x1)),
-    (0x1D708, (0x13D5, 0x1)),
-    (0x1D781, (0x144E, 0x1)),
-    (0x01FDE, (0x103, 0x3)),
-    (0x1D64F, (0x131E, 0x1)),
-    (0x02FBD, (0x416, 0x1)),
-    (0x1D500, (0x11DB, 0x1)),
-    (0x033D7, (0x918, 0x2)),
-    (0x033A3, (0x897, 0x3)),
-    (0x1D502, (0x11DD, 0x1)),
-    (0x1D444, (0x112B, 0x1)),
-    (0x1D7C0, (0x148D, 0x1)),
-    (0x1D489, (0x116F, 0x1)),
-    (0x0FC4A, (0xB0A, 0x2)),
-    (0x0FCC3, (0xC0D, 0x2)),
-    (0x033A5, (0x89D, 0x2)),
-    (0x1D6C6, (0x1393, 0x1)),
-    (0x03258, (0x59C, 0x2)),
-    (0x02149, (0x1B2, 0x1)),
-    (0x107BA, (0x10C2, 0x1)),
-    (0x0FED6, (0xF74, 0x1)),
-    (0x1EE05, (0x150D, 0x1)),
-    (0x02EF3, (0x358, 0x1)),
-    (0x0FF94, (0x103C, 0x1)),
-    (0x0FC65, (0xB47, 0x3)),
-    (0x1E04E, (0x14E9, 0x1)),
-    (0x0FB91, (0x9FA, 0x1)),
-    (0x0FD12, (0xCB0, 0x2)),
-    (0x1D6C8, (0x1395, 0x1)),
-    (0x0FE4B, (0xED5, 0x2)),
-    (0x0249F, (0x2CE, 0x3)),
-    (0x01DA3, (0x0CD, 0x1)),
-    (0x032C2, (0x634, 0x2)),
-    (0x01D51, (0x0AA, 0x1)),
-    (0x1D7FF, (0x14CA, 0x1)),
-    (0x02076, (0x145, 0x1)),
-    (0x02F3C, (0x395, 0x1)),
-    (0x0FF63, (0x100B, 0x1)),
-    (0x01D3C, (0x096, 0x1)),
-    (0x1E03E, (0x14D9, 0x1)),
-    (0x1FBF5, (0x1686, 0x1)),
-    (0x001CC, (0x036, 0x2)),
-    (0x03286, (0x5E7, 0x1)),
-    (0x1D4EB, (0x11C6, 0x1)),
-    (0x1F230, (0x1658, 0x1)),
-    (0x0FCAA, (0xBDB, 0x2)),
-    (0x02FC5, (0x41E, 0x1)),
-    (0x03227, (0x530, 0x3)),
-    (0x0FB00, (0x993, 0x2)),
-    (0x1F13E, (0x1611, 0x1)),
-    (0x0FE77, (0xF00, 0x2)),
-    (0x1D7B5, (0x1482, 0x1)),
-    (0x0FFBB, (0x1063, 0x1)),
-    (0x03353, (0x7CE, 0x4)),
-    (0x01D9B, (0x0C5, 0x1)),
-    (0x1D72B, (0x13F8, 0x1)),
-    (0x1F21B, (0x1643, 0x1)),
-    (0x0338B, (0x860, 0x2)),
-    (0x02F61, (0x3BA, 0x1)),
-    (0x02C7C, (0x354, 0x1)),
-    (0x0FC00, (0xA71, 0x3)),
-    (0x0FF96, (0x103E, 0x1)),
-    (0x003F0, (0x068, 0x1)),
-    (0x1EE0D, (0x1515, 0x1)),
-    (0x0FF6D, (0x1015, 0x1)),
-    (0x0FD54, (0xD14, 0x3)),
-    (0x0FE33, (0xEBD, 0x1)),
-    (0x02F09, (0x362, 0x1)),
-    (0x1D5A1, (0x1270, 0x1)),
-    (0x03233, (0x554, 0x3)),
-    (0x02F21, (0x37A, 0x1)),
-    (0x1D4F4, (0x11CF, 0x1)),
-    (0x02FAA, (0x403, 0x1)),
-    (0x02F55, (0x3AE, 0x1)),
-    (0x1D49A, (0x1180, 0x1)),
-    (0x1F234, (0x165C, 0x1)),
-    (0x1E060, (0x14FB, 0x1)),
-    (0x1D6E0, (0x13AD, 0x1)),
-    (0x1D433, (0x111A, 0x1)),
-    (0x1D77B, (0x1448, 0x1)),
-    (0x0FD22, (0xCD0, 0x2)),
-    (0x03141, (0x44C, 0x1)),
-    (0x0FE9C, (0xF3A, 0x1)),
-    (0x1D46D, (0x1153, 0x1)),
-    (0x0329D, (0x5FE, 0x1)),
-    (0x032EC, (0x671, 0x1)),
-    (0x0FFBC, (0x1064, 0x1)),
-    (0x0FC5F, (0xB35, 0x3)),
-    (0x1EE7B, (0x155F, 0x1)),
-    (0x03236, (0x55D, 0x3)),
-    (0x1D67B, (0x134A, 0x1)),
-    (0x033E1, (0x931, 0x2)),
-    (0x1EE18, (0x1520, 0x1)),
-    (0x024E3, (0x340, 0x1)),
-    (0x1F22E, (0x1656, 0x1)),
-    (0x1D657, (0x1326, 0x1)),
-    (0x1D4B7, (0x1195, 0x1)),
-    (0x030FF, (0x43A, 0x2)),
-    (0x0FB64, (0x9CD, 0x1)),
-    (0x0FCFF, (0xC8A, 0x2)),
-    (0x000B9, (0x00D, 0x1)),
-    (0x03139, (0x444, 0x1)),
-    (0x01D3E, (0x098, 0x1)),
-    (0x003D6, (0x067, 0x1)),
-    (0x02088, (0x157, 0x1)),
-    (0x0FE54, (0xEDF, 0x1)),
-    (0x03263, (0x5AF, 0x1)),
-    (0x0FFC4, (0x1069, 0x1)),
-    (0x1D7CB, (0x1498, 0x1)),
-    (0x1D584, (0x1253, 0x1)),
-    (0x02100, (0x16D, 0x3)),
-    (0x03332, (0x74F, 0x6)),
-    (0x0FBF2, (0xA4F, 0x3)),
-    (0x0317B, (0x486, 0x1)),
-    (0x0FBF1, (0xA4C, 0x3)),
-    (0x001C6, (0x029, 0x3)),
-    (0x0FC83, (0xB88, 0x2)),
-    (0x024A7, (0x2E6, 0x3)),
-    (0x1D6C9, (0x1396, 0x1)),
-    (0x01D53, (0x0AC, 0x1)),
-    (0x032BA, (0x624, 0x2)),
-    (0x1F13C, (0x160F, 0x1)),
-    (0x02178, (0x213, 0x2)),
-    (0x1F237, (0x165F, 0x1)),
-    (0x1D751, (0x141E, 0x1)),
-    (0x1D479, (0x115F, 0x1)),
-    (0x0215D, (0x1DB, 0x3)),
-    (0x02F17, (0x370, 0x1)),
-    (0x0FF48, (0xFF0, 0x1)),
-    (0x0FC38, (0xAE6, 0x2)),
-    (0x1D465, (0x114B, 0x1)),
-    (0x02FCD, (0x426, 0x1)),
-    (0x01D59, (0x0B2, 0x1)),
-    (0x1D65F, (0x132E, 0x1)),
-    (0x03393, (0x872, 0x3)),
-    (0x024E9, (0x346, 0x1)),
-    (0x024DB, (0x338, 0x1)),
-    (0x0FD0B, (0xCA2, 0x2)),
-    (0x0208A, (0x159, 0x1)),
-    (0x0FE5A, (0xEE5, 0x1)),
-    (0x01D4B, (0x0A5, 0x1)),
-    (0x0FD0D, (0xCA6, 0x2)),
-    (0x01D2E, (0x08A, 0x1)),
-    (0x03288, (0x5E9, 0x1)),
-    (0x1D699, (0x1368, 0x1)),
-    (0x0FE92, (0xF30, 0x1)),
-    (0x1F11A, (0x15CA, 0x3)),
-    (0x1D589, (0x1258, 0x1)),
-    (0x1E04B, (0x14E6, 0x1)),
-    (0x02F3D, (0x396, 0x1)),
-    (0x1D45A, (0x1140, 0x1)),
-    (0x0FF4C, (0xFF4, 0x1)),
-    (0x1D789, (0x1456, 0x1)),
-    (0x0A7F2, (0x989, 0x1)),
-    (0x02497, (0x2B6, 0x3)),
-    (0x0FF7C, (0x1024, 0x1)),
-    (0x033D6, (0x915, 0x3)),
-    (0x0FFA6, (0x104E, 0x1)),
-    (0x1E033, (0x14CE, 0x1)),
-    (0x1D581, (0x1250, 0x1)),
-    (0x0FF2D, (0xFD5, 0x1)),
-    (0x1D46F, (0x1155, 0x1)),
-    (0x1D5F5, (0x12C4, 0x1)),
-    (0x1EE7E, (0x1561, 0x1)),
-    (0x1D497, (0x117D, 0x1)),
-    (0x1D594, (0x1263, 0x1)),
-    (0x1D499, (0x117F, 0x1)),
-    (0x1D57C, (0x124B, 0x1)),
-    (0x01D32, (0x08D, 0x1)),
-    (0x1D5CB, (0x129A, 0x1)),
-    (0x1D783, (0x1450, 0x1)),
-    (0x1D4E8, (0x11C3, 0x1)),
-    (0x1D58E, (0x125D, 0x1)),
-    (0x0FF0D, (0xFB5, 0x1)),
-    (0x0FB88, (0x9F1, 0x1)),
-    (0x1D474, (0x115A, 0x1)),
-    (0x02F52, (0x3AB, 0x1)),
-    (0x1D68E, (0x135D, 0x1)),
-    (0x03297, (0x5F8, 0x1)),
-    (0x1EE83, (0x1565, 0x1)),
-    (0x02FCB, (0x424, 0x1)),
-    (0x0FF32, (0xFDA, 0x1)),
-    (0x0FFAB, (0x1053, 0x1)),
-    (0x1CCEF, (0x10DC, 0x1)),
-    (0x0FC95, (0xBAC, 0x2)),
-    (0x02A76, (0x351, 0x3)),
-    (0x0FE74, (0xEFC, 0x2)),
-    (0x1D63A, (0x1309, 0x1)),
-    (0x1D4CB, (0x11A6, 0x1)),
-    (0x033BF, (0x8E0, 0x2)),
-    (0x1D664, (0x1333, 0x1)),
-    (0x1F224, (0x164C, 0x1)),
-    (0x00676, (0x072, 0x2)),
-    (0x03277, (0x5CC, 0x2)),
-    (0x1D6AC, (0x1379, 0x1)),
-    (0x033E9, (0x941, 0x3)),
-    (0x0FEBE, (0xF5C, 0x1)),
-    (0x0FEE8, (0xF86, 0x1)),
-    (0x0FF3C, (0xFE4, 0x1)),
-    (0x1D7BE, (0x148B, 0x1)),
-    (0x0FDA0, (0xDF2, 0x3)),
-    (0x0314B, (0x456, 0x1)),
-    (0x02F79, (0x3D2, 0x1)),
-    (0x0FC66, (0xB4A, 0x3)),
-    (0x0FD1F, (0xCCA, 0x2)),
-    (0x0FB81, (0x9EA, 0x1)),
-    (0x0FCC9, (0xC19, 0x2)),
-    (0x1D5B5, (0x1284, 0x1)),
-    (0x0FEF4, (0xF92, 0x1)),
-    (0x0339F, (0x88C, 0x3)),
-    (0x1D6FD, (0x13CA, 0x1)),
-    (0x02107, (0x17C, 0x1)),
-    (0x0FE9E, (0xF3C, 0x1)),
-    (0x1D745, (0x1412, 0x1)),
-    (0x0249D, (0x2C8, 0x3)),
-    (0x02F8F, (0x3E8, 0x1)),
-    (0x1EE31, (0x1534, 0x1)),
-    (0x1D5B0, (0x127F, 0x1)),
-    (0x1D5F3, (0x12C2, 0x1)),
-    (0x01D5F, (0x0B8, 0x1)),
-    (0x1D7BB, (0x1488, 0x1)),
-    (0x0FF33, (0xFDB, 0x1)),
-    (0x1EE5B, (0x1548, 0x1)),
-    (0x1D747, (0x1414, 0x1)),
-    (0x0337D, (0x83F, 0x2)),
-    (0x0FCF8, (0xC7C, 0x2)),
-    (0x1D796, (0x1463, 0x1)),
-    (0x03194, (0x49C, 0x1)),
-    (0x03196, (0x49E, 0x1)),
-    (0x03292, (0x5F3, 0x1)),
-    (0x0FD3D, (0xD06, 0x2)),
-    (0x1D535, (0x120B, 0x1)),
-    (0x03149, (0x454, 0x1)),
-    (0x1D62D, (0x12FC, 0x1)),
-    (0x0FF55, (0xFFD, 0x1)),
-    (0x0FDB6, (0xE34, 0x3)),
-    (0x1D604, (0x12D3, 0x1)),
-    (0x02095, (0x163, 0x1)),
-    (0x03219, (0x4FE, 0x4)),
-    (0x032C8, (0x640, 0x2)),
-    (0x1CCDA, (0x10C7, 0x1)),
-    (0x0210E, (0x183, 0x1)),
-    (0x0FC2C, (0xACE, 0x2)),
-    (0x1F108, (0x15A6, 0x2)),
-    (0x1D687, (0x1356, 0x1)),
-    (0x1D702, (0x13CF, 0x1)),
-    (0x1D615, (0x12E4, 0x1)),
-    (0x02F0C, (0x365, 0x1)),
-    (0x03185, (0x490, 0x1)),
-    (0x1D42A, (0x1111, 0x1)),
-    (0x03254, (0x594, 0x2)),
-    (0x0FFB9, (0x1061, 0x1)),
-    (0x1D428, (0x110F, 0x1)),
-    (0x1D72E, (0x13FB, 0x1)),
-    (0x0209A, (0x168, 0x1)),
-    (0x1D689, (0x1358, 0x1)),
-    (0x033E2, (0x933, 0x2)),
-    (0x0FC75, (0xB6C, 0x2)),
-    (0x0FBF6, (0xA5B, 0x3)),
-    (0x0FBDA, (0xA26, 0x1)),
-    (0x1D44A, (0x1131, 0x1)),
-    (0x0FF5C, (0x1004, 0x1)),
-    (0x0FEE3, (0xF81, 0x1)),
-    (0x02162, (0x1E6, 0x3)),
-    (0x03181, (0x48C, 0x1)),
-    (0x0321E, (0x515, 0x6)),
-    (0x032BE, (0x62C, 0x2)),
-    (0x1F201, (0x1634, 0x2)),
-    (0x0FDF7, (0xE84, 0x4)),
-    (0x107A5, (0x10AE, 0x1)),
-    (0x0FC1F, (0xAB4, 0x2)),
-    (0x0FC84, (0xB8A, 0x2)),
-    (0x033C2, (0x8E6, 0x4)),
-    (0x0FDF6, (0xE80, 0x4)),
-    (0x02FA0, (0x3F9, 0x1)),
-    (0x1F109, (0x15A8, 0x2)),
-    (0x024B4, (0x30D, 0x3)),
-    (0x1D5B7, (0x1286, 0x1)),
-    (0x0248F, (0x2A0, 0x2)),
-    (0x0247A, (0x25D, 0x3)),
-    (0x0AB5E, (0x990, 0x1)),
-    (0x032DA, (0x65F, 0x1)),
-    (0x0FD50, (0xD08, 0x3)),
-    (0x0336B, (0x811, 0x3)),
-    (0x024D9, (0x336, 0x1)),
-    (0x0FD16, (0xCB8, 0x2)),
-    (0x03251, (0x58E, 0x2)),
-    (0x02F90, (0x3E9, 0x1)),
-    (0x0FE8F, (0xF2D, 0x1)),
-    (0x03398, (0x87E, 0x2)),
-    (0x02F1C, (0x375, 0x1)),
-    (0x0FCE1, (0xC4B, 0x2)),
-    (0x0249C, (0x2C5, 0x3)),
-    (0x1D7C9, (0x1496, 0x1)),
-    (0x0FD62, (0xD3E, 0x3)),
-    (0x0FD1B, (0xCC2, 0x2)),
-    (0x03373, (0x828, 0x2)),
-    (0x1E054, (0x14EF, 0x1)),
-    (0x0FD06, (0xC98, 0x2)),
-    (0x02FCA, (0x423, 0x1)),
-    (0x1D526, (0x11FC, 0x1)),
-    (0x02461, (0x22D, 0x1)),
-    (0x03136, (0x441, 0x1)),
-    (0x0FC7D, (0xB7C, 0x2)),
-    (0x0FB87, (0x9F0, 0x1)),
-    (0x0FEAC, (0xF4A, 0x1)),
-    (0x0317E, (0x489, 0x1)),
-    (0x032E7, (0x66C, 0x1)),
-    (0x1D76B, (0x1438, 0x1)),
-    (0x0FB9C, (0xA05, 0x1)),
-    (0x1D44B, (0x1132, 0x1)),
-    (0x1EE06, (0x150E, 0x1)),
-    (0x03216, (0x4F2, 0x4)),
-    (0x033BD, (0x8DC, 0x2)),
-    (0x1F148, (0x161B, 0x1)),
-    (0x1F216, (0x163E, 0x1)),
-    (0x1D4AC, (0x118B, 0x1)),
-    (0x0FB13, (0x9A3, 0x2)),
-    (0x1D5CC, (0x129B, 0x1)),
-    (0x1F214, (0x163C, 0x1)),
-    (0x0FC20, (0xAB6, 0x2)),
-    (0x02F04, (0x35D, 0x1)),
-    (0x1D78D, (0x145A, 0x1)),
-    (0x0FCA9, (0xBD9, 0x2)),
-    (0x0FE62, (0xEED, 0x1)),
-    (0x0FC7A, (0xB76, 0x2)),
-    (0x1D4F6, (0x11D1, 0x1)),
-    (0x1E034, (0x14CF, 0x1)),
-    (0x0FC1E, (0xAB2, 0x2)),
-    (0x01D5C, (0x0B5, 0x1)),
-    (0x01D4C, (0x0A6, 0x1)),
-    (0x0246A, (0x237, 0x2)),
-    (0x0FBD6, (0xA22, 0x1)),
-    (0x02F7B, (0x3D4, 0x1)),
-    (0x033CB, (0x8FD, 0x2)),
-    (0x0FD08, (0xC9C, 0x2)),
-    (0x1F190, (0x1630, 0x2)),
-    (0x1CCE4, (0x10D1, 0x1)),
-    (0x0FD78, (0xD80, 0x3)),
-    (0x0336D, (0x817, 0x3)),
-    (0x0A7F4, (0x98B, 0x1)),
-    (0x0FCF3, (0xC70, 0x3)),
-    (0x0217D, (0x21C, 0x1)),
-    (0x1D5A0, (0x126F, 0x1)),
-    (0x0FD5F, (0xD35, 0x3)),
-    (0x000B4, (0x008, 0x2)),
-    (0x0322E, (0x545, 0x3)),
-    (0x1EEBA, (0x1594, 0x1)),
-    (0x1F229, (0x1651, 0x1)),
-    (0x1D5DD, (0x12AC, 0x1)),
-    (0x1E067, (0x1502, 0x1)),
-    (0x0FC5A, (0xB2A, 0x2)),
-    (0x0FD95, (0xDD1, 0x3)),
-    (0x1F118, (0x15C4, 0x3)),
-    (0x1EE08, (0x1510, 0x1)),
-    (0x02FC8, (0x421, 0x1)),
-    (0x0FCC6, (0xC13, 0x2)),
-    (0x1D6B1, (0x137E, 0x1)),
-    (0x1D4CD, (0x11A8, 0x1)),
-    (0x1D472, (0x1158, 0x1)),
-    (0x1D74C, (0x1419, 0x1)),
-    (0x1D54C, (0x121C, 0x1)),
-    (0x1E031, (0x14CC, 0x1)),
-    (0x02490, (0x2A2, 0x2)),
-    (0x0FC09, (0xA88, 0x2)),
-    (0x1FBF4, (0x1685, 0x1)),
-    (0x02460, (0x22C, 0x1)),
-    (0x0FF07, (0xFAF, 0x1)),
-    (0x0FBF9, (0xA64, 0x3)),
-    (0x02154, (0x1C0, 0x3)),
-    (0x1D679, (0x1348, 0x1)),
-    (0x03223, (0x524, 0x3)),
-    (0x1D712, (0x13DF, 0x1)),
-    (0x0FE99, (0xF37, 0x1)),
-    (0x1D6D8, (0x13A5, 0x1)),
-    (0x1D677, (0x1346, 0x1)),
-    (0x1CCE7, (0x10D4, 0x1)),
-    (0x1D470, (0x1156, 0x1)),
-    (0x0FC69, (0xB53, 0x3)),
-    (0x02FC6, (0x41F, 0x1)),
-    (0x1D541, (0x1215, 0x1)),
-    (0x1D7E1, (0x14AC, 0x1)),
-    (0x0FF75, (0x101D, 0x1)),
-    (0x032D4, (0x659, 0x1)),
-    (0x01DAE, (0x0D8, 0x1)),
-    (0x0FFDC, (0x107B, 0x1)),
-    (0x033D4, (0x910, 0x2)),
-    (0x0FC94, (0xBAA, 0x2)),
-    (0x0FB28, (0x9B5, 0x1)),
-    (0x0FD67, (0xD4D, 0x3)),
-    (0x1CCE2, (0x10CF, 0x1)),
-    (0x0211A, (0x18D, 0x1)),
-    (0x0FE38, (0xEC2, 0x1)),
-    (0x01D39, (0x094, 0x1)),
-    (0x1D7F3, (0x14BE, 0x1)),
-    (0x1F11F, (0x15D9, 0x3)),
-    (0x0FF91, (0x1039, 0x1)),
-    (0x032E2, (0x667, 0x1)),
-    (0x0212D, (0x19B, 0x1)),
-    (0x1D467, (0x114D, 0x1)),
-    (0x02FA2, (0x3FB, 0x1)),
-    (0x0FC36, (0xAE2, 0x2)),
-    (0x1D730, (0x13FD, 0x1)),
-    (0x02F25, (0x37E, 0x1)),
-    (0x1D7D3, (0x149E, 0x1)),
-    (0x0FC27, (0xAC4, 0x2)),
-    (0x02079, (0x148, 0x1)),
-    (0x1D5A7, (0x1276, 0x1)),
-    (0x1D478, (0x115E, 0x1)),
-    (0x1F242, (0x166A, 0x3)),
-    (0x1EE71, (0x1557, 0x1)),
-    (0x1D59B, (0x126A, 0x1)),
-    (0x1078B, (0x1094, 0x1)),
-    (0x1D6F2, (0x13BF, 0x1)),
-    (0x0FDBC, (0xE46, 0x3)),
-    (0x0FB73, (0x9DC, 0x1)),
-    (0x02F69, (0x3C2, 0x1)),
-    (0x0200A, (0x11D, 0x1)),
-    (0x1EE69, (0x1550, 0x1)),
-    (0x1D57B, (0x124A, 0x1)),
-    (0x0FCEA, (0xC5D, 0x2)),
-    (0x0323F, (0x578, 0x3)),
-    (0x1D45C, (0x1142, 0x1)),
-    (0x0FFA0, (0x1048, 0x1)),
-    (0x1D429, (0x1110, 0x1)),
-    (0x1D5CA, (0x1299, 0x1)),
-    (0x1079C, (0x10A5, 0x1)),
-    (0x02F29, (0x382, 0x1)),
-    (0x0FD8D, (0xDBF, 0x3)),
-    (0x0FE50, (0xEDC, 0x1)),
-    (0x1D793, (0x1460, 0x1)),
-    (0x0209C, (0x16A, 0x1)),
-    (0x03340, (0x789, 0x5)),
-    (0x1EE7A, (0x155E, 0x1)),
-    (0x0326E, (0x5BA, 0x2)),
-    (0x1D69C, (0x136B, 0x1)),
-    (0x0317C, (0x487, 0x1)),
-    (0x1D424, (0x110B, 0x1)),
-    (0x0FCBB, (0xBFD, 0x2)),
-    (0x0FB7E, (0x9E7, 0x1)),
-    (0x1D678, (0x1347, 0x1)),
-    (0x024C6, (0x323, 0x1)),
-    (0x1E06B, (0x1506, 0x1)),
-    (0x1F110, (0x15AC, 0x3)),
-    (0x01D43, (0x09D, 0x1)),
-    (0x02498, (0x2B9, 0x3)),
-    (0x1D6AB, (0x1378, 0x1)),
-    (0x0FD7E, (0xD92, 0x3)),
-    (0x0FD9A, (0xDE0, 0x3)),
-    (0x1D449, (0x1130, 0x1)),
-    (0x1D5D9, (0x12A8, 0x1)),
-    (0x10784, (0x108E, 0x1)),
-    (0x01D5A, (0x0B3, 0x1)),
-    (0x0FC05, (0xA80, 0x2)),
-    (0x024BC, (0x319, 0x1)),
-    (0x033FB, (0x977, 0x3)),
-    (0x02F42, (0x39B, 0x1)),
-    (0x0338F, (0x868, 0x2)),
-    (0x0FC70, (0xB62, 0x2)),
-    (0x02091, (0x15F, 0x1)),
-    (0x03183, (0x48E, 0x1)),
-    (0x0336E, (0x81A, 0x3)),
-    (0x02093, (0x161, 0x1)),
-    (0x1D78C, (0x1459, 0x1)),
-    (0x1D5C6, (0x1295, 0x1)),
-    (0x0FDB5, (0xE31, 0x3)),
-    (0x1D5F9, (0x12C8, 0x1)),
-    (0x1D4BF, (0x119B, 0x1)),
-    (0x02F9F, (0x3F8, 0x1)),
-    (0x0319A, (0x4A2, 0x1)),
-    (0x03275, (0x5C8, 0x2)),
-    (0x1D5D1, (0x12A0, 0x1)),
-    (0x0FFED, (0x1089, 0x1)),
-    (0x0FDA4, (0xDFE, 0x3)),
-    (0x0FED1, (0xF6F, 0x1)),
-    (0x0FEA7, (0xF45, 0x1)),
-    (0x1D6A3, (0x1372, 0x1)),
-    (0x0FCE3, (0xC4F, 0x2)),
-    (0x1EEB1, (0x158B, 0x1)),
-    (0x03317, (0x6E5, 0x5)),
-    (0x0FE80, (0xF12, 0x1)),
-    (0x02101, (0x170, 0x3)),
-    (0x0328C, (0x5ED, 0x1)),
-    (0x0FBFD, (0xA6E, 0x1)),
-    (0x02F5F, (0x3B8, 0x1)),
-    (0x03278, (0x5CE, 0x2)),
-    (0x0FF11, (0xFB9, 0x1)),
-    (0x02F1A, (0x373, 0x1)),
-    (0x1EE90, (0x1571, 0x1)),
-    (0x024D5, (0x332, 0x1)),
-    (0x0247E, (0x26A, 0x4)),
-    (0x0FB93, (0x9FC, 0x1)),
-    (0x0FD10, (0xCAC, 0x2)),
-    (0x1D68D, (0x135C, 0x1)),
-    (0x1CCE8, (0x10D5, 0x1)),
-    (0x003F2, (0x06A, 0x1)),
-    (0x01DB9, (0x0E3, 0x1)),
-    (0x02F18, (0x371, 0x1)),
-    (0x1F149, (0x161C, 0x1)),
-    (0x01D65, (0x0BE, 0x1)),
-    (0x0FE8A, (0xF25, 0x2)),
-    (0x1F129, (0x15F7, 0x3)),
-    (0x0210D, (0x182, 0x1)),
-    (0x1D40E, (0x10F5, 0x1)),
-    (0x0333E, (0x783, 0x4)),
-    (0x1EE09, (0x1511, 0x1)),
-    (0x033DC, (0x925, 0x2)),
-    (0x0FDB4, (0xE2E, 0x3)),
-    (0x02099, (0x167, 0x1)),
-    (0x0FD2D, (0xCE6, 0x2)),
-    (0x032A0, (0x601, 0x1)),
-    (0x0FEBD, (0xF5B, 0x1)),
-    (0x0FF73, (0x101B, 0x1)),
-    (0x032D8, (0x65D, 0x1)),
-    (0x10794, (0x109D, 0x1)),
-    (0x0FBAA, (0xA15, 0x1)),
-    (0x0FE37, (0xEC1, 0x1)),
-    (0x0FF1A, (0xFC2, 0x1)),
-    (0x0FCA2, (0xBCB, 0x2)),
-    (0x0FD85, (0xDA7, 0x3)),
-    (0x1D78B, (0x1458, 0x1)),
-    (0x1D6A8, (0x1375, 0x1)),
-    (0x1D778, (0x1445, 0x1)),
-    (0x02F1B, (0x374, 0x1)),
-    (0x000B2, (0x006, 0x1)),
-    (0x03359, (0x7E4, 0x2)),
-    (0x03179, (0x484, 0x1)),
-    (0x0FB99, (0xA02, 0x1)),
-    (0x1D5B2, (0x1281, 0x1)),
-    (0x107A3, (0x10AC, 0x1)),
-    (0x1D626, (0x12F5, 0x1)),
-    (0x0318A, (0x495, 0x1)),
-    (0x1D4C0, (0x119C, 0x1)),
-    (0x0FBDF, (0xA2C, 0x1)),
-    (0x1D686, (0x1355, 0x1)),
-    (0x0FE40, (0xECA, 0x1)),
-    (0x02F2C, (0x385, 0x1)),
-    (0x1F136, (0x1609, 0x1)),
-    (0x02FCF, (0x428, 0x1)),
-    (0x02F3F, (0x398, 0x1)),
-    (0x0FE3E, (0xEC8, 0x1)),
-    (0x0327C, (0x5D6, 0x5)),
-    (0x0FF14, (0xFBC, 0x1)),
-    (0x1D53E, (0x1213, 0x1)),
-    (0x0314A, (0x455, 0x1)),
-    (0x1D636, (0x1305, 0x1)),
-    (0x0FDC3, (0xE5B, 0x3)),
-    (0x02F95, (0x3EE, 0x1)),
-    (0x1F113, (0x15B5, 0x3)),
-    (0x1D481, (0x1167, 0x1)),
-    (0x01DAA, (0x0D4, 0x1)),
-    (0x1D5F2, (0x12C1, 0x1)),
-    (0x1D5BD, (0x128C, 0x1)),
-    (0x1E045, (0x14E0, 0x1)),
-    (0x02F6A, (0x3C3, 0x1)),
-    (0x0FB8C, (0x9F5, 0x1)),
-    (0x02F5B, (0x3B4, 0x1)),
-    (0x1D7D4, (0x149F, 0x1)),
-    (0x0335E, (0x7EE, 0x2)),
-    (0x1D565, (0x1234, 0x1)),
-    (0x1D442, (0x1129, 0x1)),
-    (0x1D48A, (0x1170, 0x1)),
-    (0x0FCF2, (0xC6D, 0x3)),
-    (0x1F142, (0x1615, 0x1)),
-    (0x1D544, (0x1218, 0x1)),
-    (0x1D452, (0x1139, 0x1)),
-    (0x002D9, (0x049, 0x2)),
-    (0x1D573, (0x1242, 0x1)),
-    (0x0FF54, (0xFFC, 0x1)),
-    (0x0FCDC, (0xC3F, 0x2)),
-    (0x0FC4F, (0xB14, 0x2)),
-    (0x1D540, (0x1214, 0x1)),
-    (0x0FEAD, (0xF4B, 0x1)),
-    (0x0FCE0, (0xC48, 0x3)),
-    (0x0FDA6, (0xE04, 0x3)),
-    (0x0FB23, (0x9B0, 0x1)),
-    (0x1D446, (0x112D, 0x1)),
-    (0x1D66E, (0x133D, 0x1)),
-    (0x1EE07, (0x150F, 0x1)),
-    (0x01D36, (0x091, 0x1)),
-    (0x0FD1E, (0xCC8, 0x2)),
-    (0x10782, (0x108C, 0x1)),
-    (0x03160, (0x46B, 0x1)),
-    (0x03338, (0x76A, 0x4)),
-    (0x1D7C3, (0x1490, 0x1)),
-    (0x1F14F, (0x1628, 0x2)),
-    (0x1D41C, (0x1103, 0x1)),
-    (0x0FF60, (0x1008, 0x1)),
-    (0x1D7C1, (0x148E, 0x1)),
-    (0x1D473, (0x1159, 0x1)),
-    (0x0313F, (0x44A, 0x1)),
-    (0x1D582, (0x1251, 0x1)),
-    (0x0FC0F, (0xA94, 0x2)),
-    (0x1D569, (0x1238, 0x1)),
-    (0x03336, (0x762, 0x5)),
-    (0x03355, (0x7D7, 0x2)),
-    (0x1EE4B, (0x153F, 0x1)),
-    (0x03169, (0x474, 0x1)),
-    (0x0FB65, (0x9CE, 0x1)),
-    (0x0FFA7, (0x104F, 0x1)),
-    (0x03323, (0x719, 0x3)),
-    (0x1D6BC, (0x1389, 0x1)),
-    (0x01D4D, (0x0A7, 0x1)),
-    (0x1D7FB, (0x14C6, 0x1)),
-    (0x03300, (0x686, 0x5)),
-    (0x0FDF9, (0xE8C, 0x3)),
-    (0x1EE24, (0x152A, 0x1)),
-    (0x1EE03, (0x150C, 0x1)),
-    (0x03230, (0x54B, 0x3)),
-    (0x0FC19, (0xAA8, 0x2)),
-    (0x024A3, (0x2DA, 0x3)),
-    (0x1F239, (0x1661, 0x1)),
-    (0x0318C, (0x497, 0x1)),
-    (0x1D588, (0x1257, 0x1)),
-    (0x0FF69, (0x1011, 0x1)),
-    (0x0246F, (0x241, 0x2)),
-    (0x02F13, (0x36C, 0x1)),
-    (0x024C4, (0x321, 0x1)),
-    (0x03178, (0x483, 0x1)),
-    (0x1EE81, (0x1563, 0x1)),
-    (0x02E9F, (0x357, 0x1)),
-    (0x1D6AD, (0x137A, 0x1)),
-    (0x0FC4D, (0xB10, 0x2)),
-    (0x0FEAF, (0xF4D, 0x1)),
-    (0x033F4, (0x962, 0x3)),
-    (0x032E1, (0x666, 0x1)),
-    (0x03319, (0x6EE, 0x6)),
-    (0x033C1, (0x8E4, 0x2)),
-    (0x1F100, (0x1596, 0x2)),
-    (0x02F34, (0x38D, 0x1)),
-    (0x1E030, (0x14CB, 0x1)),
-    (0x0FD9D, (0xDE9, 0x3)),
-    (0x1D47F, (0x1165, 0x1)),
-    (0x0FBA1, (0xA0A, 0x1)),
-    (0x1D48D, (0x1173, 0x1)),
-    (0x1F228, (0x1650, 0x1)),
-    (0x02120, (0x191, 0x2)),
-    (0x0FE88, (0xF21, 0x2)),
-    (0x0FB4F, (0x9B7, 0x2)),
-    (0x0205F, (0x140, 0x1)),
-    (0x033C9, (0x8F9, 0x2)),
-    (0x0207F, (0x14E, 0x1)),
-    (0x1D716, (0x13E3, 0x1)),
-    (0x1D673, (0x1342, 0x1)),
-    (0x1EE9A, (0x157B, 0x1)),
-    (0x1D7D5, (0x14A0, 0x1)),
-    (0x1D649, (0x1318, 0x1)),
-    (0x1EE5F, (0x154A, 0x1)),
-    (0x1D75A, (0x1427, 0x1)),
-    (0x1D5D4, (0x12A3, 0x1)),
-    (0x002E2, (0x055, 0x1)),
-    (0x0FEC1, (0xF5F, 0x1)),
-    (0x0309F, (0x438, 0x2)),
-    (0x0FB5E, (0x9C7, 0x1)),
-    (0x1D47E, (0x1164, 0x1)),
-    (0x1D707, (0x13D4, 0x1)),
-    (0x02F5E, (0x3B7, 0x1)),
-    (0x0FB9D, (0xA06, 0x1)),
-    (0x03326, (0x723, 0x3)),
-    (0x0FEA3, (0xF41, 0x1)),
-    (0x1E038, (0x14D3, 0x1)),
-    (0x01FC1, (0x0F4, 0x3)),
-    (0x1D71B, (0x13E8, 0x1)),
-    (0x032F4, (0x679, 0x1)),
-    (0x03346, (0x79E, 0x3)),
-    (0x1D7A0, (0x146D, 0x1)),
-    (0x02F4F, (0x3A8, 0x1)),
-    (0x03361, (0x7F4, 0x2)),
-    (0x1F211, (0x1638, 0x1)),
-    (0x1EE2F, (0x1532, 0x1)),
-    (0x1D4ED, (0x11C8, 0x1)),
-    (0x0FC9A, (0xBB9, 0x3)),
-    (0x1D4E1, (0x11BC, 0x1)),
-    (0x032A8, (0x609, 0x1)),
-    (0x1F226, (0x164E, 0x1)),
-    (0x000B8, (0x00B, 0x2)),
-    (0x1EE54, (0x1545, 0x1)),
-    (0x01D69, (0x0C2, 0x1)),
-    (0x0207B, (0x14A, 0x1)),
-    (0x1079B, (0x10A4, 0x1)),
-    (0x0FC0E, (0xA92, 0x2)),
-    (0x1EE1E, (0x1526, 0x1)),
-    (0x1D518, (0x11EF, 0x1)),
-    (0x1D420, (0x1107, 0x1)),
-    (0x0FBA3, (0xA0C, 0x1)),
-    (0x02FD0, (0x429, 0x1)),
-    (0x1D4C6, (0x11A1, 0x1)),
-    (0x03133, (0x43E, 0x1)),
-    (0x0FD33, (0xCF2, 0x2)),
-    (0x0FC12, (0xA9A, 0x2)),
-    (0x0FFBA, (0x1062, 0x1)),
-    (0x01D50, (0x0A9, 0x1)),
-    (0x0248A, (0x296, 0x2)),
-    (0x0FD05, (0xC96, 0x2)),
-    (0x0FDB9, (0xE3D, 0x3)),
-    (0x0210C, (0x181, 0x1)),
-    (0x0339B, (0x884, 0x2)),
-    (0x033E6, (0x93B, 0x2)),
-    (0x1D613, (0x12E2, 0x1)),
-    (0x1D7B2, (0x147F, 0x1)),
-    (0x0FBAF, (0xA1A, 0x1)),
-    (0x01DA2, (0x0CC, 0x1)),
-    (0x0316E, (0x479, 0x1)),
-    (0x02F48, (0x3A1, 0x1)),
-    (0x000AF, (0x004, 0x2)),
-    (0x10799, (0x10A2, 0x1)),
-    (0x0FBEB, (0xA3A, 0x3)),
-    (0x0315F, (0x46A, 0x1)),
-    (0x1EEB2, (0x158C, 0x1)),
-    (0x1D468, (0x114E, 0x1)),
-    (0x1D42F, (0x1116, 0x1)),
-    (0x0FC55, (0xB20, 0x2)),
-    (0x1D51C, (0x11F3, 0x1)),
-    (0x0FF92, (0x103A, 0x1)),
-    (0x03395, (0x878, 0x2)),
-    (0x1D674, (0x1343, 0x1)),
-    (0x1D722, (0x13EF, 0x1)),
-    (0x0FBE6, (0xA33, 0x1)),
-    (0x033A4, (0x89A, 0x3)),
-    (0x033F7, (0x96B, 0x3)),
-    (0x02001, (0x114, 0x1)),
-    (0x1F14B, (0x161F, 0x2)),
-    (0x1D733, (0x1400, 0x1)),
-    (0x0FEC0, (0xF5E, 0x1)),
-    (0x1D67D, (0x134C, 0x1)),
-    (0x0FC23, (0xABC, 0x2)),
-    (0x1D601, (0x12D0, 0x1)),
-    (0x02F85, (0x3DE, 0x1)),
-    (0x0037A, (0x058, 0x2)),
-    (0x032CF, (0x652, 0x3)),
-    (0x1F200, (0x1632, 0x2)),
-    (0x02499, (0x2BC, 0x3)),
-    (0x1D490, (0x1176, 0x1)),
-    (0x032F0, (0x675, 0x1)),
-    (0x02F19, (0x372, 0x1)),
-    (0x1D696, (0x1365, 0x1)),
-    (0x1D55E, (0x122D, 0x1)),
-    (0x0FCF5, (0xC76, 0x2)),
-    (0x0FC7F, (0xB80, 0x2)),
-    (0x0FC64, (0xB44, 0x3)),
-    (0x0FFB3, (0x105B, 0x1)),
-    (0x1F105, (0x15A0, 0x2)),
-    (0x1D748, (0x1415, 0x1)),
-    (0x1D405, (0x10EC, 0x1)),
-    (0x02113, (0x188, 0x1)),
-    (0x0FEE1, (0xF7F, 0x1)),
-    (0x1E05F, (0x14FA, 0x1)),
-    (0x0FCFD, (0xC86, 0x2)),
-    (0x0FF4E, (0xFF6, 0x1)),
-    (0x1D7F7, (0x14C2, 0x1)),
-    (0x0FFD5, (0x1076, 0x1)),
-    (0x0FCB3, (0xBED, 0x2)),
-    (0x0FB52, (0x9BB, 0x1)),
-    (0x1D595, (0x1264, 0x1)),
-    (0x1F147, (0x161A, 0x1)),
-    (0x0FE5D, (0xEE8, 0x1)),
-    (0x1D655, (0x1324, 0x1)),
-    (0x1D6B5, (0x1382, 0x1)),
-    (0x024BF, (0x31C, 0x1)),
-    (0x03256, (0x598, 0x2)),
-    (0x01FFE, (0x111, 0x2)),
-    (0x024BB, (0x318, 0x1)),
-    (0x1D6AF, (0x137C, 0x1)),
-    (0x03260, (0x5AC, 0x1)),
-    (0x02F01, (0x35A, 0x1)),
-    (0x0FC80, (0xB82, 0x2)),
-    (0x0325C, (0x5A4, 0x2)),
-    (0x1D6A0, (0x136F, 0x1)),
-    (0x03383, (0x84D, 0x2)),
-    (0x0FB22, (0x9AF, 0x1)),
-    (0x1D61C, (0x12EB, 0x1)),
-    (0x0216F, (0x200, 0x1)),
-    (0x01D57, (0x0B0, 0x1)),
-    (0x024D8, (0x335, 0x1)),
-    (0x1D773, (0x1440, 0x1)),
-    (0x0FC5E, (0xB32, 0x3)),
-    (0x1F213, (0x163A, 0x2)),
-    (0x1D70F, (0x13DC, 0x1)),
-    (0x1D5E6, (0x12B5, 0x1)),
-    (0x0FFA4, (0x104C, 0x1)),
-    (0x1F12D, (0x15FF, 0x2)),
-    (0x0FB16, (0x9A9, 0x2)),
-    (0x1E05A, (0x14F5, 0x1)),
-    (0x0FC79, (0xB74, 0x2)),
-    (0x02FA7, (0x400, 0x1)),
-    (0x0327A, (0x5D2, 0x2)),
-    (0x032FB, (0x680, 0x1)),
-    (0x002D8, (0x047, 0x2)),
-    (0x1EEA5, (0x1580, 0x1)),
-    (0x1CCEA, (0x10D7, 0x1)),
-    (0x02493, (0x2AA, 0x3)),
-    (0x1E04A, (0x14E5, 0x1)),
-    (0x1D598, (0x1267, 0x1)),
-    (0x02FAB, (0x404, 0x1)),
-    (0x1D758, (0x1425, 0x1)),
-    (0x1D4DA, (0x11B5, 0x1)),
-    (0x0FBDB, (0xA27, 0x1)),
-    (0x02164, (0x1EB, 0x1)),
-    (0x0FF83, (0x102B, 0x1)),
-    (0x02F94, (0x3ED, 0x1)),
-    (0x02483, (0x27E, 0x4)),
-    (0x032ED, (0x672, 0x1)),
-    (0x0334F, (0x7C2, 0x3)),
-    (0x1D737, (0x1404, 0x1)),
-    (0x0FDC4, (0xE5E, 0x3)),
-    (0x0FE55, (0xEE0, 0x1)),
-    (0x0FF7D, (0x1025, 0x1)),
-    (0x02489, (0x294, 0x2)),
-    (0x02FB5, (0x40E, 0x1)),
-    (0x0FE3C, (0xEC6, 0x1)),
-    (0x1D628, (0x12F7, 0x1)),
-    (0x032F5, (0x67A, 0x1)),
-    (0x0FF05, (0xFAD, 0x1)),
-    (0x0FFA8, (0x1050, 0x1)),
-    (0x1EE1D, (0x1525, 0x1)),
-    (0x03159, (0x464, 0x1)),
-    (0x02A0C, (0x348, 0x4)),
-    (0x1D746, (0x1413, 0x1)),
-    (0x0FECF, (0xF6D, 0x1)),
-    (0x0FBFB, (0xA6A, 0x3)),
-    (0x1D6D6, (0x13A3, 0x1)),
-    (0x02152, (0x1B9, 0x4)),
-    (0x1E043, (0x14DE, 0x1)),
-    (0x03172, (0x47D, 0x1)),
-    (0x107AA, (0x10B3, 0x1)),
-    (0x0FBDC, (0xA28, 0x1)),
-    (0x02158, (0x1CC, 0x3)),
-    (0x1D63D, (0x130C, 0x1)),
-    (0x0FEE2, (0xF80, 0x1)),
-    (0x024DC, (0x339, 0x1)),
-    (0x0FDC0, (0xE52, 0x3)),
-    (0x02F1E, (0x377, 0x1)),
-    (0x01D54, (0x0AD, 0x1)),
-    (0x1D759, (0x1426, 0x1)),
-    (0x1D553, (0x1222, 0x1)),
-    (0x10795, (0x109E, 0x1)),
-    (0x033B9, (0x8D4, 0x2)),
-    (0x1D5D2, (0x12A1, 0x1)),
-    (0x1D451, (0x1138, 0x1)),
-    (0x0335C, (0x7EA, 0x2)),
-    (0x03283, (0x5E4, 0x1)),
-    (0x032E6, (0x66B, 0x1)),
-    (0x03281, (0x5E2, 0x1)),
-    (0x107B0, (0x10B9, 0x1)),
-    (0x03371, (0x823, 0x3)),
-    (0x0FCF1, (0xC6B, 0x2)),
-    (0x1EE86, (0x1568, 0x1)),
-    (0x0FFDB, (0x107A, 0x1)),
-    (0x1D647, (0x1316, 0x1)),
-    (0x03210, (0x4DA, 0x4)),
-    (0x1D7CA, (0x1497, 0x1)),
-    (0x0FDF4, (0xE78, 0x4)),
-    (0x0FD0C, (0xCA4, 0x2)),
-    (0x02007, (0x11A, 0x1)),
-    (0x0333B, (0x775, 0x5)),
-    (0x02A75, (0x34F, 0x2)),
-    (0x03231, (0x54E, 0x3)),
-    (0x02F8D, (0x3E6, 0x1)),
-    (0x1D6DD, (0x13AA, 0x1)),
-    (0x107B5, (0x10BD, 0x1)),
-    (0x02F54, (0x3AD, 0x1)),
-    (0x0FB98, (0xA01, 0x1)),
-    (0x0FD60, (0xD38, 0x3)),
-    (0x1D495, (0x117B, 0x1)),
-    (0x0FF4D, (0xFF5, 0x1)),
-    (0x0313B, (0x446, 0x1)),
-    (0x0A7F3, (0x98A, 0x1)),
-    (0x1D7E5, (0x14B0, 0x1)),
-    (0x1D4F2, (0x11CD, 0x1)),
-    (0x1D65E, (0x132D, 0x1)),
-    (0x02F6D, (0x3C6, 0x1)),
-    (0x1EE00, (0x1509, 0x1)),
-    (0x02103, (0x174, 0x2)),
-    (0x0FF5D, (0x1005, 0x1)),
-    (0x1F16B, (0x162C, 0x2)),
-    (0x0FF8A, (0x1032, 0x1)),
-    (0x1D4B3, (0x1191, 0x1)),
-    (0x032FD, (0x682, 0x1)),
-    (0x1D74B, (0x1418, 0x1)),
-    (0x0FD03, (0xC92, 0x2)),
-    (0x1D471, (0x1157, 0x1)),
-    (0x1D576, (0x1245, 0x1)),
-    (0x1D493, (0x1179, 0x1)),
-    (0x0FF6A, (0x1012, 0x1)),
-    (0x0FE31, (0xEBB, 0x1)),
-    (0x0323A, (0x569, 0x3)),
-    (0x01D49, (0x0A3, 0x1)),
-    (0x1D7E9, (0x14B4, 0x1)),
-    (0x0FB6E, (0x9D7, 0x1)),
-    (0x0FC51, (0xB18, 0x2)),
-    (0x033ED, (0x94D, 0x3)),
-    (0x0FE15, (0xEB2, 0x1)),
-    (0x02F28, (0x381, 0x1)),
-    (0x1D6A4, (0x1373, 0x1)),
-    (0x1D4E2, (0x11BD, 0x1)),
-    (0x032CE, (0x650, 0x2)),
-    (0x02094, (0x162, 0x1)),
-    (0x1D6FC, (0x13C9, 0x1)),
-    (0x032F6, (0x67B, 0x1)),
-    (0x0FE9A, (0xF38, 0x1)),
-    (0x01DBE, (0x0E8, 0x1)),
-    (0x01DB7, (0x0E1, 0x1)),
-    (0x1D4BD, (0x1199, 0x1)),
-    (0x0FDA1, (0xDF5, 0x3)),
-    (0x1D6D7, (0x13A4, 0x1)),
-    (0x1D7BF, (0x148C, 0x1)),
-    (0x03316, (0x6DF, 0x6)),
-    (0x03391, (0x86C, 0x3)),
-    (0x1D744, (0x1411, 0x1)),
-    (0x1D41F, (0x1106, 0x1)),
-    (0x1EE84, (0x1566, 0x1)),
-    (0x0FFBE, (0x1066, 0x1)),
-    (0x03244, (0x587, 0x1)),
-    (0x1D58D, (0x125C, 0x1)),
-    (0x02FD1, (0x42A, 0x1)),
-    (0x0FF19, (0xFC1, 0x1)),
-    (0x1D5C5, (0x1294, 0x1)),
-    (0x1D663, (0x1332, 0x1)),
-    (0x1D723, (0x13F0, 0x1)),
-    (0x1F247, (0x1679, 0x3)),
-    (0x1F23B, (0x1663, 0x1)),
-    (0x0FCD6, (0xC33, 0x2)),
-    (0x01DB5, (0x0DF, 0x1)),
-    (0x02083, (0x152, 0x1)),
-    (0x024C9, (0x326, 0x1)),
-    (0x1D6CD, (0x139A, 0x1)),
-    (0x1D5A9, (0x1278, 0x1)),
-    (0x03307, (0x6A2, 0x6)),
-    (0x1D7DF, (0x14AA, 0x1)),
-    (0x1D692, (0x1361, 0x1)),
-    (0x1D509, (0x11E3, 0x1)),
-    (0x024AF, (0x2FE, 0x3)),
-    (0x1CCDE, (0x10CB, 0x1)),
-    (0x1EE93, (0x1574, 0x1)),
-    (0x0FD14, (0xCB4, 0x2)),
-    (0x0316C, (0x477, 0x1)),
-    (0x0FC42, (0xAFA, 0x2)),
-    (0x0FB70, (0x9D9, 0x1)),
-    (0x02F06, (0x35F, 0x1)),
-    (0x0FD8B, (0xDB9, 0x3)),
-    (0x03271, (0x5C0, 0x2)),
-    (0x03342, (0x791, 0x3)),
-    (0x03269, (0x5B5, 0x1)),
-    (0x1FBF1, (0x1682, 0x1)),
-    (0x032D6, (0x65B, 0x1)),
-    (0x0209B, (0x169, 0x1)),
-    (0x1D7B8, (0x1485, 0x1)),
-    (0x0FF56, (0xFFE, 0x1)),
-    (0x0FE60, (0xEEB, 0x1)),
-    (0x1D5E4, (0x12B3, 0x1)),
-    (0x1F233, (0x165B, 0x1)),
-    (0x0FF1D, (0xFC5, 0x1)),
-    (0x0FCF6, (0xC78, 0x2)),
-    (0x1D4DB, (0x11B6, 0x1)),
-    (0x02F67, (0x3C0, 0x1)),
-    (0x1D53B, (0x1210, 0x1)),
-    (0x0FBA4, (0xA0D, 0x2)),
-    (0x0336A, (0x80E, 0x3)),
-    (0x0FD1C, (0xCC4, 0x2)),
-    (0x1E061, (0x14FC, 0x1)),
-    (0x0FB95, (0x9FE, 0x1)),
-    (0x03257, (0x59A, 0x2)),
-    (0x1D560, (0x122F, 0x1)),
-    (0x032C5, (0x63A, 0x2)),
-    (0x1EE30, (0x1533, 0x1)),
-    (0x1D466, (0x114C, 0x1)),
-    (0x0FE9F, (0xF3D, 0x1)),
-    (0x03038, (0x431, 0x1)),
-    (0x032AE, (0x60F, 0x1)),
-    (0x1D7B0, (0x147D, 0x1)),
-    (0x1CCF0, (0x10DD, 0x1)),
-    (0x1D7E6, (0x14B1, 0x1)),
-    (0x0FCA0, (0xBC7, 0x2)),
-    (0x0336C, (0x814, 0x3)),
-    (0x0FD2B, (0xCE2, 0x2)),
-    (0x0FBAE, (0xA19, 0x1)),
-    (0x0FFB4, (0x105C, 0x1)),
-    (0x02F33, (0x38C, 0x1)),
-    (0x0FD3C, (0xD04, 0x2)),
-    (0x0FF31, (0xFD9, 0x1)),
-    (0x0332C, (0x736, 0x4)),
-    (0x1F12B, (0x15FD, 0x1)),
-    (0x033FE, (0x980, 0x3)),
-    (0x01D41, (0x09B, 0x1)),
-    (0x107B8, (0x10C0, 0x1)),
-    (0x1D62A, (0x12F9, 0x1)),
-    (0x1D631, (0x1300, 0x1)),
-    (0x1EEAC, (0x1586, 0x1)),
-    (0x02FB8, (0x411, 0x1)),
-    (0x1D4FB, (0x11D6, 0x1)),
-    (0x0FF76, (0x101E, 0x1)),
-    (0x0FC37, (0xAE4, 0x2)),
-    (0x0FC29, (0xAC8, 0x2)),
-    (0x1D6E6, (0x13B3, 0x1)),
-    (0x107A1, (0x10AA, 0x1)),
-    (0x0319D, (0x4A5, 0x1)),
-    (0x0FCAC, (0xBDF, 0x2)),
-    (0x03344, (0x798, 0x3)),
-    (0x0FE4C, (0xED7, 0x2)),
-    (0x0208B, (0x15A, 0x1)),
-    (0x107A9, (0x10B2, 0x1)),
-    (0x0FE96, (0xF34, 0x1)),
-    (0x0FC56, (0xB22, 0x2)),
-    (0x0FBFA, (0xA67, 0x3)),
-    (0x0FB85, (0x9EE, 0x1)),
-    (0x0FD89, (0xDB3, 0x3)),
-    (0x03295, (0x5F6, 0x1)),
-    (0x0FCA8, (0xBD7, 0x2)),
-    (0x002E0, (0x053, 0x1)),
-    (0x03350, (0x7C5, 0x3)),
-    (0x02147, (0x1B0, 0x1)),
-    (0x01D30, (0x08B, 0x1)),
-    (0x03387, (0x855, 0x2)),
-    (0x0317F, (0x48A, 0x1)),
-    (0x1F107, (0x15A4, 0x2)),
-    (0x1D555, (0x1224, 0x1)),
-    (0x1D6BE, (0x138B, 0x1)),
-    (0x0FEF5, (0xF93, 0x3)),
-    (0x03351, (0x7C8, 0x4)),
-    (0x1D4AB, (0x118A, 0x1)),
-    (0x02479, (0x25A, 0x3)),
-    (0x024CB, (0x328, 0x1)),
-    (0x0FF1F, (0xFC7, 0x1)),
-    (0x03212, (0x4E2, 0x4)),
-    (0x032C0, (0x630, 0x2)),
-    (0x1EE75, (0x155A, 0x1)),
-    (0x0A7F8, (0x98C, 0x1)),
-    (0x1F245, (0x1673, 0x3)),
-    (0x0FB57, (0x9C0, 0x1)),
-    (0x1F215, (0x163D, 0x1)),
-    (0x0FEA9, (0xF47, 0x1)),
-    (0x02484, (0x282, 0x4)),
-    (0x02FBF, (0x418, 0x1)),
-    (0x0FED5, (0xF73, 0x1)),
-    (0x1D4D6, (0x11B1, 0x1)),
-    (0x02F7A, (0x3D3, 0x1)),
-    (0x03242, (0x581, 0x3)),
-    (0x1D456, (0x113C, 0x1)),
-    (0x0FE14, (0xEB1, 0x1)),
-    (0x0FC59, (0xB28, 0x2)),
-    (0x0FCD7, (0xC35, 0x2)),
-    (0x0FE43, (0xECD, 0x1)),
-    (0x1D7D1, (0x149C, 0x1)),
-    (0x1D563, (0x1232, 0x1)),
-    (0x0FC4E, (0xB12, 0x2)),
-    (0x1F250, (0x167F, 0x1)),
-    (0x1D4F5, (0x11D0, 0x1)),
-    (0x0FBD5, (0xA21, 0x1)),
-    (0x1D661, (0x1330, 0x1)),
-    (0x03252, (0x590, 0x2)),
-    (0x0FECC, (0xF6A, 0x1)),
-    (0x0FF85, (0x102D, 0x1)),
-    (0x0FD51, (0xD0B, 0x3)),
-    (0x1D605, (0x12D4, 0x1)),
-    (0x0FBE5, (0xA32, 0x1)),
-    (0x1D4CC, (0x11A7, 0x1)),
-    (0x1F119, (0x15C7, 0x3)),
-    (0x1D638, (0x1307, 0x1)),
-    (0x0FDAF, (0xE1F, 0x3)),
-    (0x1D739, (0x1406, 0x1)),
-    (0x1F21A, (0x1642, 0x1)),
-    (0x0318E, (0x499, 0x1)),
-    (0x0316D, (0x478, 0x1)),
-    (0x03374, (0x82A, 0x3)),
-    (0x02469, (0x235, 0x2)),
-    (0x0FB29, (0x9B6, 0x1)),
-    (0x1EE01, (0x150A, 0x1)),
-    (0x0248E, (0x29E, 0x2)),
-    (0x1D623, (0x12F2, 0x1)),
-    (0x032D9, (0x65E, 0x1)),
-    (0x1D531, (0x1207, 0x1)),
-    (0x03146, (0x451, 0x1)),
-    (0x1E051, (0x14EC, 0x1)),
-    (0x1D48C, (0x1172, 0x1)),
-    (0x0FCF0, (0xC69, 0x2)),
-    (0x0FB80, (0x9E9, 0x1)),
-    (0x0FEB1, (0xF4F, 0x1)),
-    (0x02FD3, (0x42C, 0x1)),
-    (0x0FD77, (0xD7D, 0x3)),
-    (0x02482, (0x27A, 0x4)),
-    (0x03152, (0x45D, 0x1)),
-    (0x02176, (0x20C, 0x3)),
-    (0x024B8, (0x315, 0x1)),
-    (0x0322C, (0x53F, 0x3)),
-    (0x0FE56, (0xEE1, 0x1)),
-    (0x03397, (0x87C, 0x2)),
-    (0x02476, (0x251, 0x3)),
-    (0x10796, (0x109F, 0x1)),
-    (0x1D4D0, (0x11AB, 0x1)),
-    (0x107B3, (0x10BB, 0x1)),
-    (0x1D779, (0x1446, 0x1)),
-    (0x0FD7C, (0xD8C, 0x3)),
-    (0x02F22, (0x37B, 0x1)),
-    (0x0FC34, (0xADE, 0x2)),
-    (0x0FCB9, (0xBF9, 0x2)),
-    (0x1D676, (0x1345, 0x1)),
-    (0x1D408, (0x10EF, 0x1)),
-    (0x0FB74, (0x9DD, 0x1)),
-    (0x0332A, (0x72D, 0x3)),
-    (0x1D7B3, (0x1480, 0x1)),
-    (0x03202, (0x4AE, 0x3)),
-    (0x02230, (0x229, 0x3)),
-    (0x0FE65, (0xEF0, 0x1)),
-    (0x032DF, (0x664, 0x1)),
-    (0x03177, (0x482, 0x1)),
-    (0x0FD2C, (0xCE4, 0x2)),
-    (0x0FEED, (0xF8B, 0x1)),
-    (0x1F12A, (0x15FA, 0x3)),
-    (0x02F62, (0x3BB, 0x1)),
-    (0x02FA6, (0x3FF, 0x1)),
-    (0x0248C, (0x29A, 0x2)),
-    (0x0FF6B, (0x1013, 0x1)),
-    (0x0FEF1, (0xF8F, 0x1)),
-    (0x1D4B5, (0x1193, 0x1)),
-    (0x1D6E4, (0x13B1, 0x1)),
-    (0x03312, (0x6CD, 0x4)),
-    (0x1EE21, (0x1528, 0x1)),
-    (0x0FD18, (0xCBC, 0x2)),
-    (0x1D57A, (0x1249, 0x1)),
-    (0x0216C, (0x1FD, 0x1)),
-    (0x03131, (0x43C, 0x1)),
-    (0x03217, (0x4F6, 0x4)),
-    (0x03386, (0x853, 0x2)),
-    (0x1D711, (0x13DE, 0x1)),
-    (0x03200, (0x4A8, 0x3)),
-    (0x1D62C, (0x12FB, 0x1)),
-    (0x1D590, (0x125F, 0x1)),
-    (0x1D53C, (0x1211, 0x1)),
-    (0x032CB, (0x648, 0x3)),
-    (0x0FD29, (0xCDE, 0x2)),
-    (0x1EEA1, (0x157D, 0x1)),
-    (0x0FE4F, (0xEDB, 0x1)),
-    (0x0FB54, (0x9BD, 0x1)),
-    (0x0322A, (0x539, 0x3)),
-    (0x1F14A, (0x161D, 0x2)),
-    (0x02136, (0x1A2, 0x1)),
-    (0x0FF2B, (0xFD3, 0x1)),
-    (0x0FCFB, (0xC82, 0x2)),
-    (0x0FDB2, (0xE28, 0x3)),
-    (0x1EE36, (0x1538, 0x1)),
-    (0x0FD2E, (0xCE8, 0x2)),
-    (0x0FF46, (0xFEE, 0x1)),
-    (0x1CCF8, (0x10E5, 0x1)),
-    (0x1D60C, (0x12DB, 0x1)),
-    (0x033AB, (0x8AE, 0x3)),
-    (0x1D7BC, (0x1489, 0x1)),
-    (0x1D4C1, (0x119D, 0x1)),
-    (0x0FDBD, (0xE49, 0x3)),
-    (0x03331, (0x74C, 0x3)),
-    (0x1EE34, (0x1536, 0x1)),
-    (0x1D6CC, (0x1399, 0x1)),
-    (0x1D44F, (0x1136, 0x1)),
-    (0x0332E, (0x73F, 0x6)),
-    (0x0FF6E, (0x1016, 0x1)),
-    (0x01D78, (0x0C4, 0x1)),
-    (0x1D780, (0x144D, 0x1)),
-    (0x1D765, (0x1432, 0x1)),
-    (0x0FE71, (0xEF8, 0x2)),
-    (0x02496, (0x2B3, 0x3)),
-    (0x1D460, (0x1146, 0x1)),
-    (0x1D756, (0x1423, 0x1)),
-    (0x0FC5C, (0xB2E, 0x2)),
-    (0x0337F, (0x843, 0x4)),
-    (0x0FC2D, (0xAD0, 0x2)),
-    (0x024AA, (0x2EF, 0x3)),
-    (0x1D546, (0x1219, 0x1)),
-    (0x1D624, (0x12F3, 0x1)),
-    (0x1EEB9, (0x1593, 0x1)),
-    (0x01D63, (0x0BC, 0x1)),
-    (0x001CA, (0x032, 0x2)),
-    (0x03240, (0x57B, 0x3)),
-    (0x1D4E3, (0x11BE, 0x1)),
-    (0x1E062, (0x14FD, 0x1)),
-    (0x03225, (0x52A, 0x3)),
-    (0x0FE79, (0xF04, 0x2)),
-    (0x02F20, (0x379, 0x1)),
-    (0x0FCAD, (0xBE1, 0x2)),
-    (0x0FC85, (0xB8C, 0x2)),
-    (0x02FB9, (0x412, 0x1)),
-    (0x1D7D2, (0x149D, 0x1)),
-    (0x0332D, (0x73A, 0x5)),
-    (0x1D4E6, (0x11C1, 0x1)),
-    (0x024E2, (0x33F, 0x1)),
-    (0x1EEAF, (0x1589, 0x1)),
-    (0x032B0, (0x611, 0x1)),
-    (0x1D575, (0x1244, 0x1)),
-    (0x0FD6E, (0xD62, 0x3)),
-    (0x0FD71, (0xD6B, 0x3)),
-    (0x1D521, (0x11F7, 0x1)),
-    (0x0FF9D, (0x1045, 0x1)),
-    (0x1D671, (0x1340, 0x1)),
-    (0x0247B, (0x260, 0x3)),
-    (0x1D7D7, (0x14A2, 0x1)),
-    (0x03174, (0x47F, 0x1)),
-    (0x1D7A8, (0x1475, 0x1)),
-    (0x1F16C, (0x162E, 0x2)),
-    (0x0FB14, (0x9A5, 0x2)),
-    (0x1D5D3, (0x12A2, 0x1)),
-    (0x1F123, (0x15E5, 0x3)),
-    (0x0FBAD, (0xA18, 0x1)),
-    (0x03308, (0x6A8, 0x4)),
-    (0x03164, (0x46F, 0x1)),
-    (0x02033, (0x128, 0x2)),
-    (0x1D644, (0x1313, 0x1)),
-    (0x0FCD8, (0xC37, 0x2)),
-    (0x0FC22, (0xABA, 0x2)),
-    (0x0215A, (0x1D2, 0x3)),
-    (0x1D64B, (0x131A, 0x1)),
-    (0x0FBEF, (0xA46, 0x3)),
-    (0x01DBF, (0x0E9, 0x1)),
-    (0x033A6, (0x89F, 0x3)),
-    (0x0FD74, (0xD74, 0x3)),
-    (0x1D533, (0x1209, 0x1)),
-    (0x01DA4, (0x0CE, 0x1)),
-    (0x1D40A, (0x10F1, 0x1)),
-    (0x0FEA0, (0xF3E, 0x1)),
-    (0x01D61, (0x0BA, 0x1)),
-    (0x1E03A, (0x14D5, 0x1)),
-    (0x0FCB5, (0xBF1, 0x2)),
-    (0x1D4D7, (0x11B2, 0x1)),
-    (0x03145, (0x450, 0x1)),
-    (0x0FC98, (0xBB3, 0x3)),
-    (0x1D539, (0x120F, 0x1)),
-    (0x1EE72, (0x1558, 0x1)),
-    (0x001F2, (0x03A, 0x2)),
-    (0x1D51E, (0x11F4, 0x1)),
-    (0x024A0, (0x2D1, 0x3)),
-    (0x0FB56, (0x9BF, 0x1)),
-    (0x024BD, (0x31A, 0x1)),
-    (0x0FFB7, (0x105F, 0x1)),
-    (0x1D77D, (0x144A, 0x1)),
-    (0x0217E, (0x21D, 0x1)),
-    (0x1D43E, (0x1125, 0x1)),
-    (0x033D3, (0x90E, 0x2)),
-    (0x0FE7D, (0xF0C, 0x2)),
-    (0x000AA, (0x003, 0x1)),
-    (0x0309B, (0x434, 0x2)),
-    (0x01D4A, (0x0A4, 0x1)),
-    (0x1EE52, (0x1544, 0x1)),
-    (0x032A6, (0x607, 0x1)),
-    (0x1EE7C, (0x1560, 0x1)),
-    (0x0332F, (0x745, 0x4)),
-    (0x01D46, (0x0A0, 0x1)),
-    (0x1D792, (0x145F, 0x1)),
-    (0x1D593, (0x1262, 0x1)),
-    (0x032BB, (0x626, 0x2)),
-    (0x03343, (0x794, 0x4)),
-    (0x02FD4, (0x42D, 0x1)),
-    (0x0FCD2, (0xC2B, 0x2)),
-    (0x1D66B, (0x133A, 0x1)),
-    (0x107AE, (0x10B7, 0x1)),
-    (0x0FC3C, (0xAEE, 0x2)),
-    (0x1D656, (0x1325, 0x1)),
-    (0x02464, (0x230, 0x1)),
-    (0x02105, (0x176, 0x3)),
-    (0x0FB5C, (0x9C5, 0x1)),
-    (0x0FE47, (0xECF, 0x1)),
-    (0x0329A, (0x5FB, 0x1)),
-    (0x1EE42, (0x153C, 0x1)),
-    (0x01D3D, (0x097, 0x1)),
-    (0x033D8, (0x91A, 0x4)),
-    (0x1D666, (0x1335, 0x1)),
-    (0x03358, (0x7E2, 0x2)),
-    (0x0FB6C, (0x9D5, 0x1)),
-    (0x1D5A8, (0x1277, 0x1)),
-    (0x02F7E, (0x3D7, 0x1)),
-    (0x0FF3D, (0xFE5, 0x1)),
-    (0x033FD, (0x97D, 0x3)),
-    (0x0FD70, (0xD68, 0x3)),
-    (0x032A9, (0x60A, 0x1)),
-    (0x02F2B, (0x384, 0x1)),
-    (0x1D48B, (0x1171, 0x1)),
-    (0x02081, (0x150, 0x1)),
-    (0x0FE9D, (0xF3B, 0x1)),
-    (0x00F79, (0x084, 0x3)),
-    (0x0329E, (0x5FF, 0x1)),
-    (0x0247F, (0x26E, 0x4)),
-    (0x01D52, (0x0AB, 0x1)),
-    (0x02F5D, (0x3B6, 0x1)),
-    (0x02133, (0x19F, 0x1)),
-    (0x0FEAB, (0xF49, 0x1)),
-    (0x1D463, (0x1149, 0x1)),
-    (0x0FBE7, (0xA34, 0x1)),
-    (0x000BD, (0x012, 0x3)),
-    (0x0329C, (0x5FD, 0x1)),
-    (0x01D5E, (0x0B7, 0x1)),
-    (0x0FC3A, (0xAEA, 0x2)),
-    (0x002E3, (0x056, 0x1)),
-    (0x1D675, (0x1344, 0x1)),
-    (0x03354, (0x7D2, 0x5)),
-    (0x1D5E3, (0x12B2, 0x1)),
-    (0x0FE8B, (0xF27, 0x2)),
-    (0x0FF77, (0x101F, 0x1)),
-    (0x032B7, (0x61E, 0x2)),
-    (0x0FD65, (0xD47, 0x3)),
-    (0x03203, (0x4B1, 0x3)),
-    (0x1D54B, (0x121B, 0x1)),
-    (0x024CD, (0x32A, 0x1)),
-    (0x002DA, (0x04B, 0x2)),
-    (0x1D62B, (0x12FA, 0x1)),
-    (0x1EE82, (0x1564, 0x1)),
-    (0x1E04C, (0x14E7, 0x1)),
-    (0x0248B, (0x298, 0x2)),
-    (0x0FB62, (0x9CB, 0x1)),
-    (0x1F212, (0x1639, 0x1)),
-    (0x1D7FC, (0x14C7, 0x1)),
-    (0x0FFA2, (0x104A, 0x1)),
-    (0x0FC96, (0xBAE, 0x2)),
-    (0x0FCED, (0xC63, 0x2)),
-    (0x0FBA9, (0xA14, 0x1)),
-    (0x1D5A2, (0x1271, 0x1)),
-    (0x0FF9E, (0x1046, 0x1)),
-    (0x0FB5A, (0x9C3, 0x1)),
-    (0x024A4, (0x2DD, 0x3)),
-    (0x1D4B2, (0x1190, 0x1)),
-    (0x1EE11, (0x1519, 0x1)),
-    (0x0FCC8, (0xC17, 0x2)),
-    (0x03250, (0x58B, 0x3)),
-    (0x1D421, (0x1108, 0x1)),
-    (0x1D7E7, (0x14B2, 0x1)),
-    (0x033F3, (0x95F, 0x3)),
-    (0x107AC, (0x10B5, 0x1)),
-    (0x033A9, (0x8A9, 0x2)),
-    (0x1EE9B, (0x157C, 0x1)),
-    (0x02F77, (0x3D0, 0x1)),
-    (0x0FF20, (0xFC8, 0x1)),
-    (0x02089, (0x158, 0x1)),
-    (0x0FE5B, (0xEE6, 0x1)),
-    (0x0FCA3, (0xBCD, 0x2)),
-    (0x1D6B7, (0x1384, 0x1)),
-    (0x0FE76, (0xEFE, 0x2)),
-    (0x0FE59, (0xEE4, 0x1)),
-    (0x1D6D4, (0x13A1, 0x1)),
-    (0x02F6B, (0x3C4, 0x1)),
-    (0x1EE1F, (0x1527, 0x1)),
-    (0x1D74E, (0x141B, 0x1)),
-    (0x0FFD4, (0x1075, 0x1)),
-    (0x001C5, (0x026, 0x3)),
-    (0x01D2D, (0x089, 0x1)),
-    (0x02F35, (0x38E, 0x1)),
-    (0x1F104, (0x159E, 0x2)),
-    (0x0FBF4, (0xA55, 0x3)),
-    (0x1D411, (0x10F8, 0x1)),
-    (0x1D42E, (0x1115, 0x1)),
-    (0x01FEE, (0x10C, 0x3)),
-    (0x0FC54, (0xB1E, 0x2)),
-    (0x1F22F, (0x1657, 0x1)),
-    (0x1D5E2, (0x12B1, 0x1)),
-    (0x1D60F, (0x12DE, 0x1)),
-    (0x0FC6F, (0xB60, 0x2)),
-    (0x1D476, (0x115C, 0x1)),
-    (0x033CA, (0x8FB, 0x2)),
-    (0x02FCE, (0x427, 0x1)),
-    (0x1D59A, (0x1269, 0x1)),
-    (0x02175, (0x20A, 0x2)),
-    (0x1D6D0, (0x139D, 0x1)),
-    (0x02150, (0x1B3, 0x3)),
-    (0x1D7AE, (0x147B, 0x1)),
-    (0x1D6CB, (0x1398, 0x1)),
-    (0x0FC02, (0xA77, 0x3)),
-    (0x0FFC5, (0x106A, 0x1)),
-    (0x1D76A, (0x1437, 0x1)),
-    (0x0FE69, (0xEF3, 0x1)),
-    (0x0326C, (0x5B8, 0x1)),
-    (0x0FE89, (0xF23, 0x2)),
-    (0x02FBB, (0x414, 0x1)),
-    (0x1D514, (0x11EC, 0x1)),
-    (0x03036, (0x430, 0x1)),
-    (0x0FD97, (0xDD7, 0x3)),
-    (0x0FC11, (0xA98, 0x2)),
-    (0x02F44, (0x39D, 0x1)),
-    (0x0FBD3, (0xA1F, 0x1)),
-    (0x0FFCD, (0x1070, 0x1)),
-    (0x0FD88, (0xDB0, 0x3)),
-    (0x1D507, (0x11E1, 0x1)),
-    (0x0FF02, (0xFAA, 0x1)),
-    (0x1EEB3, (0x158D, 0x1)),
-    (0x1D7D6, (0x14A1, 0x1)),
-    (0x032BD, (0x62A, 0x2)),
-    (0x1D603, (0x12D2, 0x1)),
-    (0x0FC4C, (0xB0E, 0x2)),
-    (0x0FCC5, (0xC11, 0x2)),
-    (0x02F8E, (0x3E7, 0x1)),
-    (0x0FFAD, (0x1055, 0x1)),
-    (0x0FD68, (0xD50, 0x3)),
-    (0x1D435, (0x111C, 0x1)),
-    (0x0FE4E, (0xEDA, 0x1)),
-    (0x0318D, (0x498, 0x1)),
-    (0x1D75F, (0x142C, 0x1)),
-    (0x032C9, (0x642, 0x3)),
-    (0x0313A, (0x445, 0x1)),
-    (0x1D7A4, (0x1471, 0x1)),
-    (0x1F117, (0x15C1, 0x3)),
-    (0x033C7, (0x8F4, 0x3)),
-    (0x1D6E5, (0x13B2, 0x1)),
-    (0x03207, (0x4BD, 0x3)),
-    (0x1D614, (0x12E3, 0x1)),
-    (0x1D571, (0x1240, 0x1)),
-    (0x1D6F7, (0x13C4, 0x1)),
-    (0x1D52F, (0x1205, 0x1)),
-    (0x032FE, (0x683, 0x1)),
-    (0x0FDC6, (0xE64, 0x3)),
-    (0x1EE29, (0x152C, 0x1)),
-    (0x1D5EA, (0x12B9, 0x1)),
-    (0x002DB, (0x04D, 0x2)),
-    (0x0FCCB, (0xC1D, 0x2)),
-    (0x02137, (0x1A3, 0x1)),
-    (0x0FCA6, (0xBD3, 0x2)),
-    (0x02166, (0x1EE, 0x3)),
-    (0x033BC, (0x8DA, 0x2)),
-    (0x0FBD9, (0xA25, 0x1)),
-    (0x02FA9, (0x402, 0x1)),
-    (0x03206, (0x4BA, 0x3)),
-    (0x0FBE2, (0xA2F, 0x1)),
-    (0x1CCED, (0x10DA, 0x1)),
-    (0x0FCD4, (0xC2F, 0x2)),
-    (0x1EEA9, (0x1584, 0x1)),
-    (0x01D6A, (0x0C3, 0x1)),
-    (0x1E05E, (0x14F9, 0x1)),
-    (0x1D64D, (0x131C, 0x1)),
-    (0x1D504, (0x11DF, 0x1)),
-    (0x0FBAC, (0xA17, 0x1)),
-    (0x01D35, (0x090, 0x1)),
-    (0x0FC25, (0xAC0, 0x2)),
-    (0x002B5, (0x043, 0x1)),
-    (0x0FC8F, (0xBA0, 0x2)),
-    (0x1D79A, (0x1467, 0x1)),
-    (0x003D4, (0x064, 0x2)),
-    (0x03392, (0x86F, 0x3)),
-    (0x02486, (0x28A, 0x4)),
-    (0x02F1F, (0x378, 0x1)),
-    (0x03313, (0x6D1, 0x6)),
-    (0x1D4C7, (0x11A2, 0x1)),
-    (0x0325E, (0x5A8, 0x2)),
-    (0x03238, (0x563, 0x3)),
-    (0x0FD32, (0xCF0, 0x2)),
-    (0x0FF53, (0xFFB, 0x1)),
-    (0x0FE66, (0xEF1, 0x1)),
-    (0x0AB5C, (0x98E, 0x1)),
-    (0x024D7, (0x334, 0x1)),
-    (0x10783, (0x108D, 0x1)),
-    (0x024B2, (0x307, 0x3)),
-    (0x02487, (0x28E, 0x4)),
-    (0x0FF6F, (0x1017, 0x1)),
-    (0x0FC63, (0xB41, 0x3)),
-    (0x0FD6D, (0xD5F, 0x3)),
-    (0x02110, (0x185, 0x1)),
-    (0x0FBA8, (0xA13, 0x1)),
-    (0x1F251, (0x1680, 0x1)),
-    (0x0FBED, (0xA40, 0x3)),
-    (0x033BE, (0x8DE, 0x2)),
-    (0x0FB05, (0x99F, 0x2)),
-    (0x0FC99, (0xBB6, 0x3)),
-    (0x1EE15, (0x151D, 0x1)),
-    (0x1EE13, (0x151B, 0x1)),
-    (0x024A1, (0x2D4, 0x3)),
-    (0x033DE, (0x929, 0x3)),
-    (0x1D5B9, (0x1288, 0x1)),
-    (0x1D690, (0x135F, 0x1)),
-    (0x01D2C, (0x088, 0x1)),
-    (0x0FB90, (0x9F9, 0x1)),
-    (0x1D42D, (0x1114, 0x1)),
-    (0x024C2, (0x31F, 0x1)),
-    (0x1D4FF, (0x11DA, 0x1)),
-    (0x01DBC, (0x0E6, 0x1)),
-    (0x0FCB7, (0xBF5, 0x2)),
-    (0x0FC67, (0xB4D, 0x3)),
-    (0x000B3, (0x007, 0x1)),
-    (0x0FC2F, (0xAD4, 0x2)),
-    (0x03345, (0x79B, 0x3)),
-    (0x01FFD, (0x10F, 0x2)),
-    (0x1D7EC, (0x14B7, 0x1)),
-    (0x033A7, (0x8A2, 0x3)),
-    (0x1D51F, (0x11F5, 0x1)),
-    (0x032CC, (0x64B, 0x2)),
-    (0x02130, (0x19D, 0x1)),
-    (0x0FF5F, (0x1007, 0x1)),
-    (0x02174, (0x209, 0x1)),
-    (0x0337E, (0x841, 0x2)),
-    (0x1D523, (0x11F9, 0x1)),
-    (0x0207C, (0x14B, 0x1)),
-    (0x033D5, (0x912, 0x3)),
-    (0x1D65C, (0x132B, 0x1)),
-    (0x024A9, (0x2EC, 0x3)),
-    (0x0FD9F, (0xDEF, 0x3)),
-    (0x1D762, (0x142F, 0x1)),
-    (0x03154, (0x45F, 0x1)),
-    (0x0215F, (0x1E1, 0x2)),
-    (0x0FF4A, (0xFF2, 0x1)),
-    (0x1D477, (0x115D, 0x1)),
-    (0x1D400, (0x10E7, 0x1)),
-    (0x1D525, (0x11FB, 0x1)),
-    (0x03255, (0x596, 0x2)),
-    (0x1F111, (0x15AF, 0x3)),
-    (0x0FF8E, (0x1036, 0x1)),
-    (0x1D709, (0x13D6, 0x1)),
-    (0x1E06A, (0x1505, 0x1)),
-    (0x1D4E9, (0x11C4, 0x1)),
-    (0x1CCE9, (0x10D6, 0x1)),
-    (0x003F9, (0x06D, 0x1)),
-    (0x0FE3A, (0xEC4, 0x1)),
-    (0x03259, (0x59E, 0x2)),
-    (0x1D6A5, (0x1374, 0x1)),
-    (0x02F02, (0x35B, 0x1)),
-    (0x0FD01, (0xC8E, 0x2)),
-    (0x0325B, (0x5A2, 0x2)),
-    (0x02008, (0x11B, 0x1)),
-    (0x0FD8F, (0xDC5, 0x3)),
-    (0x1D7DC, (0x14A7, 0x1)),
-    (0x1D447, (0x112E, 0x1)),
-    (0x02086, (0x155, 0x1)),
-    (0x1D492, (0x1178, 0x1)),
-    (0x1D70B, (0x13D8, 0x1)),
-    (0x1D5FC, (0x12CB, 0x1)),
-    (0x0FE81, (0xF13, 0x2)),
-    (0x0FB86, (0x9EF, 0x1)),
-    (0x0FD30, (0xCEC, 0x2)),
-    (0x02F3A, (0x393, 0x1)),
-    (0x1D5BB, (0x128A, 0x1)),
-    (0x0FC9D, (0xBC1, 0x2)),
-    (0x0FC3E, (0xAF2, 0x2)),
-    (0x0FE7B, (0xF08, 0x2)),
-    (0x0FFAF, (0x1057, 0x1)),
-    (0x0FF57, (0xFFF, 0x1)),
-    (0x0FBFE, (0xA6F, 0x1)),
-    (0x1D59F, (0x126E, 0x1)),
-    (0x1D646, (0x1315, 0x1)),
-    (0x0FBF0, (0xA49, 0x3)),
-    (0x0315A, (0x465, 0x1)),
-    (0x0FEA6, (0xF44, 0x1)),
-    (0x0FCE6, (0xC55, 0x2)),
-    (0x1D554, (0x1223, 0x1)),
-    (0x1D791, (0x145E, 0x1)),
-    (0x02F1D, (0x376, 0x1)),
-    (0x03363, (0x7F9, 0x3)),
-    (0x0FC60, (0xB38, 0x3)),
-    (0x03268, (0x5B4, 0x1)),
-    (0x1D695, (0x1364, 0x1)),
-    (0x0FF29, (0xFD1, 0x1)),
-    (0x0FE57, (0xEE2, 0x1)),
-    (0x02F47, (0x3A0, 0x1)),
-    (0x0210F, (0x184, 0x1)),
-    (0x01D55, (0x0AE, 0x1)),
-    (0x1D4EF, (0x11CA, 0x1)),
-    (0x033B2, (0x8C6, 0x2)),
-    (0x024D2, (0x32F, 0x1)),
-    (0x1E049, (0x14E4, 0x1)),
-    (0x02F32, (0x38B, 0x1)),
-    (0x1CCF4, (0x10E1, 0x1)),
-    (0x1EE85, (0x1567, 0x1)),
-    (0x02F4D, (0x3A6, 0x1)),
-    (0x0FF84, (0x102C, 0x1)),
-    (0x1F114, (0x15B8, 0x3)),
-    (0x0FD7F, (0xD95, 0x3)),
-    (0x0314D, (0x458, 0x1)),
-    (0x01D62, (0x0BB, 0x1)),
-    (0x1D697, (0x1366, 0x1)),
-    (0x1F102, (0x159A, 0x2)),
-    (0x0333F, (0x787, 0x2)),
-    (0x02138, (0x1A4, 0x1)),
-    (0x1D54A, (0x121A, 0x1)),
-    (0x0FB7F, (0x9E8, 0x1)),
-    (0x0FB06, (0x9A1, 0x2)),
-    (0x0FD24, (0xCD4, 0x2)),
-    (0x1D66A, (0x1339, 0x1)),
-    (0x0FC53, (0xB1C, 0x2)),
-    (0x1D45E, (0x1144, 0x1)),
-    (0x1D76E, (0x143B, 0x1)),
-    (0x03378, (0x833, 0x3)),
-    (0x1D61F, (0x12EE, 0x1)),
-    (0x1D7A6, (0x1473, 0x1)),
-    (0x1D7C7, (0x1494, 0x1)),
-    (0x0FF2F, (0xFD7, 0x1)),
-    (0x0FC1D, (0xAB0, 0x2)),
-    (0x1D65B, (0x132A, 0x1)),
-    (0x0213B, (0x1A6, 0x3)),
-    (0x1D6BA, (0x1387, 0x1)),
-    (0x0333C, (0x77A, 0x4)),
-    (0x002B4, (0x042, 0x1)),
-    (0x0FD26, (0xCD8, 0x2)),
-    (0x0FF25, (0xFCD, 0x1)),
-    (0x0217A, (0x216, 0x2)),
-    (0x0FC13, (0xA9C, 0x2)),
-    (0x1D54E, (0x121E, 0x1)),
-    (0x00678, (0x076, 0x2)),
-    (0x1D7E8, (0x14B3, 0x1)),
-    (0x1D6D1, (0x139E, 0x1)),
-    (0x03274, (0x5C6, 0x2)),
-    (0x032E3, (0x668, 0x1)),
-    (0x1D6FF, (0x13CC, 0x1)),
-    (0x1D58A, (0x1259, 0x1)),
-    (0x0FDBB, (0xE43, 0x3)),
-    (0x1E04F, (0x14EA, 0x1)),
-    (0x0FD09, (0xC9E, 0x2)),
-    (0x024DD, (0x33A, 0x1)),
-    (0x0FCE4, (0xC51, 0x2)),
-    (0x1D47C, (0x1162, 0x1)),
-    (0x0AB5F, (0x991, 0x1)),
-    (0x0FF98, (0x1040, 0x1)),
-    (0x0FBF7, (0xA5E, 0x3)),
-    (0x03187, (0x492, 0x1)),
-    (0x0FF37, (0xFDF, 0x1)),
-    (0x02FA1, (0x3FA, 0x1)),
-    (0x0FB9E, (0xA07, 0x1)),
-    (0x03237, (0x560, 0x3)),
-    (0x0FCE7, (0xC57, 0x2)),
-    (0x1CCDC, (0x10C9, 0x1)),
-    (0x1D755, (0x1422, 0x1)),
-    (0x02011, (0x11E, 0x1)),
-    (0x1EEB7, (0x1591, 0x1)),
-    (0x0FC46, (0xB02, 0x2)),
-    (0x033DB, (0x923, 0x2)),
-    (0x0334B, (0x7B2, 0x3)),
-    (0x0339A, (0x882, 0x2)),
-    (0x0FE83, (0xF17, 0x2)),
-    (0x0FEC8, (0xF66, 0x1)),
-    (0x0FFDA, (0x1079, 0x1)),
-    (0x01D38, (0x093, 0x1)),
-    (0x0FBE8, (0xA35, 0x1)),
-    (0x1D55C, (0x122B, 0x1)),
-    (0x024A2, (0x2D7, 0x3)),
-    (0x1F131, (0x1604, 0x1)),
-    (0x0FFE2, (0x107E, 0x1)),
-    (0x0303A, (0x433, 0x1)),
-    (0x0FD35, (0xCF6, 0x2)),
-    (0x03301, (0x68B, 0x4)),
-    (0x1FBF0, (0x1681, 0x1)),
-    (0x002DC, (0x04F, 0x2)),
-    (0x0FE85, (0xF1B, 0x2)),
-    (0x01D3A, (0x095, 0x1)),
-    (0x0FC17, (0xAA4, 0x2)),
-    (0x1FBF7, (0x1688, 0x1)),
-    (0x0FB66, (0x9CF, 0x1)),
-    (0x1EEA3, (0x157F, 0x1)),
-    (0x0FD04, (0xC94, 0x2)),
-    (0x0323E, (0x575, 0x3)),
-    (0x0328D, (0x5EE, 0x1)),
-    (0x1D7BD, (0x148A, 0x1)),
-    (0x1D6C0, (0x138D, 0x1)),
-    (0x03328, (0x728, 0x2)),
-    (0x1D602, (0x12D1, 0x1)),
-    (0x1D607, (0x12D6, 0x1)),
-    (0x1F125, (0x15EB, 0x3)),
-    (0x02468, (0x234, 0x1)),
-    (0x0FE11, (0xEAE, 0x1)),
-    (0x02098, (0x166, 0x1)),
-    (0x0FD98, (0xDDA, 0x3)),
-    (0x0FC6E, (0xB5E, 0x2)),
-    (0x1CCF1, (0x10DE, 0x1)),
-    (0x03310, (0x6C5, 0x4)),
-    (0x1D530, (0x1206, 0x1)),
-    (0x02179, (0x215, 0x1)),
-    (0x00F77, (0x081, 0x3)),
-    (0x1D7B7, (0x1484, 0x1)),
-    (0x033EB, (0x947, 0x3)),
-    (0x0326D, (0x5B9, 0x1)),
-    (0x03372, (0x826, 0x2)),
-    (0x0FBD4, (0xA20, 0x1)),
-    (0x1D550, (0x1220, 0x1)),
-    (0x03144, (0x44F, 0x1)),
-    (0x002B8, (0x046, 0x1)),
-    (0x1D725, (0x13F2, 0x1)),
-    (0x1EE32, (0x1535, 0x1)),
-    (0x02131, (0x19E, 0x1)),
-    (0x033C5, (0x8EE, 0x2)),
-    (0x1CCE5, (0x10D2, 0x1)),
-    (0x0FE51, (0xEDD, 0x1)),
-    (0x0334E, (0x7BE, 0x4)),
-    (0x10785, (0x108F, 0x1)),
-    (0x1D427, (0x110E, 0x1)),
-    (0x1D6F4, (0x13C1, 0x1)),
-    (0x02075, (0x144, 0x1)),
-    (0x1D660, (0x132F, 0x1)),
-    (0x0FF5E, (0x1006, 0x1)),
-    (0x0FC0B, (0xA8C, 0x2)),
-    (0x0FD37, (0xCFA, 0x2)),
-    (0x02F03, (0x35C, 0x1)),
-    (0x024B7, (0x314, 0x1)),
-    (0x02F43, (0x39C, 0x1)),
-    (0x0FD1D, (0xCC6, 0x2)),
-    (0x03142, (0x44D, 0x1)),
-    (0x0247D, (0x266, 0x4)),
-    (0x0FF3E, (0xFE6, 0x1)),
-    (0x1D776, (0x1443, 0x1)),
-    (0x01D9F, (0x0C9, 0x1)),
-    (0x1EE16, (0x151E, 0x1)),
-    (0x1D6BD, (0x138A, 0x1)),
-    (0x02F46, (0x39F, 0x1)),
-    (0x0FF7A, (0x1022, 0x1)),
-    (0x0FEBC, (0xF5A, 0x1)),
-    (0x0FF59, (0x1001, 0x1)),
-    (0x1D665, (0x1334, 0x1)),
-    (0x1F12C, (0x15FE, 0x1)),
-    (0x02F59, (0x3B2, 0x1)),
-    (0x1D7B9, (0x1486, 0x1)),
-    (0x0321B, (0x506, 0x4)),
-    (0x0FFD2, (0x1073, 0x1)),
-    (0x02F2A, (0x383, 0x1)),
-    (0x002E1, (0x054, 0x1)),
-    (0x0FC68, (0xB50, 0x3)),
-    (0x1F128, (0x15F4, 0x3)),
-    (0x02003, (0x116, 0x1)),
-    (0x0FEC4, (0xF62, 0x1)),
-    (0x0FD75, (0xD77, 0x3)),
-    (0x02F12, (0x36B, 0x1)),
-    (0x1D6B9, (0x1386, 0x1)),
-    (0x0FD17, (0xCBA, 0x2)),
-    (0x0FDB1, (0xE25, 0x3)),
-    (0x0330D, (0x6B9, 0x4)),
-    (0x02F9D, (0x3F6, 0x1)),
-    (0x0FF43, (0xFEB, 0x1)),
-    (0x032B4, (0x618, 0x2)),
-    (0x1D72D, (0x13FA, 0x1)),
-    (0x1D669, (0x1338, 0x1)),
-    (0x0FE87, (0xF1F, 0x2)),
-    (0x1EE92, (0x1573, 0x1)),
-    (0x000A0, (0x000, 0x1)),
-    (0x1F140, (0x1613, 0x1)),
-    (0x1D685, (0x1354, 0x1)),
-    (0x02087, (0x156, 0x1)),
-    (0x1D6E9, (0x13B6, 0x1)),
-    (0x1D75D, (0x142A, 0x1)),
-    (0x02F40, (0x399, 0x1)),
-    (0x0FD5B, (0xD29, 0x3)),
-    (0x0FCBC, (0xBFF, 0x2)),
-    (0x02097, (0x165, 0x1)),
-    (0x033F6, (0x968, 0x3)),
-    (0x1D794, (0x1461, 0x1)),
-    (0x1D44D, (0x1134, 0x1)),
-    (0x1D6EF, (0x13BC, 0x1)),
-    (0x0FE70, (0xEF6, 0x2)),
-    (0x0FCFE, (0xC88, 0x2)),
-    (0x1D448, (0x112F, 0x1)),
-    (0x0FC92, (0xBA6, 0x2)),
-    (0x1D40B, (0x10F2, 0x1)),
-    (0x02161, (0x1E4, 0x2)),
-    (0x02047, (0x136, 0x2)),
-    (0x1D7F6, (0x14C1, 0x1)),
-    (0x1D691, (0x1360, 0x1)),
-    (0x1F11E, (0x15D6, 0x3)),
-    (0x0FD55, (0xD17, 0x3)),
-    (0x0FEE4, (0xF82, 0x1)),
-    (0x1D69A, (0x1369, 0x1)),
-    (0x032D2, (0x657, 0x1)),
-    (0x0FFEC, (0x1088, 0x1)),
-    (0x0FF1B, (0xFC3, 0x1)),
-    (0x03266, (0x5B2, 0x1)),
-    (0x1E056, (0x14F1, 0x1)),
-    (0x0FE10, (0xEAD, 0x1)),
-    (0x03388, (0x857, 0x3)),
-    (0x1EE97, (0x1578, 0x1)),
-    (0x03173, (0x47E, 0x1)),
-    (0x1D583, (0x1252, 0x1)),
-    (0x1FBF9, (0x168A, 0x1)),
-    (0x0FE4D, (0xED9, 0x1)),
-    (0x024DE, (0x33B, 0x1)),
-    (0x1D543, (0x1217, 0x1)),
-    (0x1D57D, (0x124C, 0x1)),
-    (0x0FF7F, (0x1027, 0x1)),
-    (0x1F240, (0x1664, 0x3)),
-    (0x1D534, (0x120A, 0x1)),
-    (0x0FD23, (0xCD2, 0x2)),
-    (0x0FF45, (0xFED, 0x1)),
-    (0x033AD, (0x8B4, 0x3)),
-    (0x1D618, (0x12E7, 0x1)),
-    (0x0FC6D, (0xB5C, 0x2)),
-    (0x000A8, (0x001, 0x2)),
-    (0x0FB77, (0x9E0, 0x1)),
-    (0x0FEFA, (0xFA2, 0x3)),
-    (0x1EE5D, (0x1549, 0x1)),
-    (0x032EA, (0x66F, 0x1)),
-    (0x02F23, (0x37C, 0x1)),
-    (0x01DAB, (0x0D5, 0x1)),
-    (0x00EDC, (0x07C, 0x2)),
-    (0x0FE97, (0xF35, 0x1)),
-    (0x0FCB4, (0xBEF, 0x2)),
-    (0x02FA5, (0x3FE, 0x1)),
-    (0x1D438, (0x111F, 0x1)),
-    (0x03195, (0x49D, 0x1)),
-    (0x1D727, (0x13F4, 0x1)),
-    (0x1D662, (0x1331, 0x1)),
-    (0x1D70E, (0x13DB, 0x1)),
-    (0x1D417, (0x10FE, 0x1)),
-    (0x1D436, (0x111D, 0x1)),
-    (0x0FC1A, (0xAAA, 0x2)),
-    (0x1D7DB, (0x14A6, 0x1)),
-    (0x1D6FB, (0x13C8, 0x1)),
-    (0x0FEF6, (0xF96, 0x3)),
-    (0x03193, (0x49B, 0x1)),
-    (0x10787, (0x1090, 0x1)),
-    (0x1E053, (0x14EE, 0x1)),
-    (0x1D651, (0x1320, 0x1)),
-    (0x1E046, (0x14E1, 0x1)),
-    (0x0FE3F, (0xEC9, 0x1)),
-    (0x0FF49, (0xFF1, 0x1)),
-    (0x02026, (0x124, 0x3)),
-    (0x033E7, (0x93D, 0x2)),
-    (0x0211C, (0x18F, 0x1)),
-    (0x02F58, (0x3B1, 0x1)),
-    (0x1D5FF, (0x12CE, 0x1)),
-    (0x0FE9B, (0xF39, 0x1)),
-    (0x0FD2F, (0xCEA, 0x2)),
-    (0x0FF09, (0xFB1, 0x1)),
-    (0x1D61A, (0x12E9, 0x1)),
-    (0x1D7AB, (0x1478, 0x1)),
-    (0x1D5A4, (0x1273, 0x1)),
-    (0x0328B, (0x5EC, 0x1)),
-    (0x1D4C3, (0x119F, 0x1)),
-    (0x1CCE6, (0x10D3, 0x1)),
-    (0x0FF0E, (0xFB6, 0x1)),
-    (0x00677, (0x074, 0x2)),
-    (0x02F00, (0x359, 0x1)),
-    (0x0248D, (0x29C, 0x2)),
-    (0x0FD27, (0xCDA, 0x2)),
-    (0x01DB6, (0x0E0, 0x1)),
-    (0x0326A, (0x5B6, 0x1)),
-    (0x1D566, (0x1235, 0x1)),
-    (0x024C7, (0x324, 0x1)),
-    (0x032FF, (0x684, 0x2)),
-    (0x10797, (0x10A0, 0x1)),
-    (0x024A5, (0x2E0, 0x3)),
-    (0x0FE30, (0xEB9, 0x2)),
-    (0x1D437, (0x111E, 0x1)),
-    (0x0FF0F, (0xFB7, 0x1)),
-    (0x0FC58, (0xB26, 0x2)),
-    (0x1D7A7, (0x1474, 0x1)),
-    (0x0215C, (0x1D8, 0x3)),
-    (0x0FDA3, (0xDFB, 0x3)),
-    (0x1D516, (0x11ED, 0x1)),
-    (0x02F8A, (0x3E3, 0x1)),
-    (0x0FD0F, (0xCAA, 0x2)),
-    (0x1D403, (0x10EA, 0x1)),
-    (0x1D413, (0x10FA, 0x1)),
-    (0x03262, (0x5AE, 0x1)),
-    (0x1EE0A, (0x1512, 0x1)),
-    (0x0FFB1, (0x1059, 0x1)),
-    (0x1F22B, (0x1653, 0x1)),
-    (0x1D703, (0x13D0, 0x1)),
-    (0x02F6E, (0x3C7, 0x1)),
-    (0x024EA, (0x347, 0x1)),
-    (0x1D73D, (0x140A, 0x1)),
-    (0x0FCDA, (0xC3B, 0x2)),
-    (0x02F49, (0x3A2, 0x1)),
-    (0x03148, (0x453, 0x1)),
-    (0x0FC0D, (0xA90, 0x2)),
-    (0x02F93, (0x3EC, 0x1)),
-    (0x033AA, (0x8AB, 0x3)),
-    (0x02F27, (0x380, 0x1)),
-    (0x032E8, (0x66D, 0x1)),
-    (0x1FBF8, (0x1689, 0x1)),
-    (0x1F101, (0x1598, 0x2)),
-    (0x1D462, (0x1148, 0x1)),
-    (0x1D749, (0x1416, 0x1)),
-    (0x1D7A9, (0x1476, 0x1)),
-    (0x1D57F, (0x124E, 0x1)),
-    (0x03132, (0x43D, 0x1)),
-    (0x0FF6C, (0x1014, 0x1)),
-    (0x0FD9C, (0xDE6, 0x3)),
-    (0x03192, (0x49A, 0x1)),
-    (0x02FC2, (0x41B, 0x1)),
-    (0x1D799, (0x1466, 0x1)),
-    (0x0213C, (0x1A9, 0x1)),
-    (0x1E06D, (0x1508, 0x1)),
-    (0x1D4E7, (0x11C2, 0x1)),
-    (0x0FB15, (0x9A7, 0x2)),
-    (0x02FBC, (0x415, 0x1)),
-    (0x024E0, (0x33D, 0x1)),
-    (0x03209, (0x4C3, 0x3)),
-    (0x033EA, (0x944, 0x3)),
-    (0x0FC6C, (0xB5A, 0x2)),
-    (0x02FAC, (0x405, 0x1)),
-    (0x1F202, (0x1636, 0x1)),
-    (0x0FBF3, (0xA52, 0x3)),
-    (0x0327B, (0x5D4, 0x2)),
-    (0x02F38, (0x391, 0x1)),
-    (0x02F2E, (0x387, 0x1)),
-    (0x00F0C, (0x080, 0x1)),
-    (0x0FDAB, (0xE13, 0x3)),
-    (0x1EE64, (0x154D, 0x1)),
-    (0x0FC3B, (0xAEC, 0x2)),
-    (0x1EE6E, (0x1554, 0x1)),
-    (0x1D63E, (0x130D, 0x1)),
-    (0x1D47D, (0x1163, 0x1)),
-    (0x0FF28, (0xFD0, 0x1)),
-    (0x0FCF4, (0xC73, 0x3)),
-    (0x0FC9E, (0xBC3, 0x2)),
-    (0x1D7AC, (0x1479, 0x1)),
-    (0x1D7FD, (0x14C8, 0x1)),
-    (0x0FB01, (0x995, 0x2)),
-    (0x0FDAE, (0xE1C, 0x3)),
-    (0x0316B, (0x476, 0x1)),
-    (0x1D63C, (0x130B, 0x1)),
-    (0x0FDB7, (0xE37, 0x3)),
-    (0x1D66D, (0x133C, 0x1)),
-    (0x03334, (0x759, 0x6)),
-    (0x0FC6A, (0xB56, 0x2)),
-    (0x1EE62, (0x154C, 0x1)),
-    (0x0338D, (0x864, 0x2)),
-    (0x033AC, (0x8B1, 0x3)),
-    (0x0330E, (0x6BD, 0x4)),
-    (0x0FE82, (0xF15, 0x2)),
-    (0x03333, (0x755, 0x4)),
-    (0x0246C, (0x23B, 0x2)),
-    (0x1D73A, (0x1407, 0x1)),
-    (0x0FC87, (0xB90, 0x2)),
-    (0x1E066, (0x1501, 0x1)),
-    (0x0FD00, (0xC8C, 0x2)),
-    (0x03291, (0x5F2, 0x1)),
-    (0x1D732, (0x13FF, 0x1)),
-    (0x0216B, (0x1FA, 0x3)),
-    (0x02FB6, (0x40F, 0x1)),
-    (0x024E7, (0x344, 0x1)),
-    (0x02FC0, (0x419, 0x1)),
-    (0x033F9, (0x971, 0x3)),
-    (0x0FC9F, (0xBC5, 0x2)),
-    (0x03188, (0x493, 0x1)),
-    (0x0FD79, (0xD83, 0x3)),
-    (0x03229, (0x536, 0x3)),
-    (0x1D4C5, (0x11A0, 0x1)),
-    (0x024B5, (0x310, 0x3)),
-    (0x1D591, (0x1260, 0x1)),
-    (0x03163, (0x46E, 0x1)),
-    (0x033DD, (0x927, 0x2)),
-    (0x032C3, (0x636, 0x2)),
-    (0x01DA9, (0x0D3, 0x1)),
-    (0x0FC4B, (0xB0C, 0x2)),
-    (0x0FBE9, (0xA36, 0x1)),
-    (0x1D71F, (0x13EC, 0x1)),
-    (0x0334C, (0x7B5, 0x5)),
-    (0x10793, (0x109C, 0x1)),
-    (0x02F56, (0x3AF, 0x1)),
-    (0x1D4D1, (0x11AC, 0x1)),
-    (0x0FB53, (0x9BC, 0x1)),
-    (0x00EB3, (0x07A, 0x2)),
-    (0x02F11, (0x36A, 0x1)),
-    (0x0FB89, (0x9F2, 0x1)),
-    (0x03201, (0x4AB, 0x3)),
-    (0x0FD82, (0xD9E, 0x3)),
-    (0x1D503, (0x11DE, 0x1)),
-    (0x0FEC5, (0xF63, 0x1)),
-    (0x1D486, (0x116C, 0x1)),
-    (0x1D753, (0x1420, 0x1)),
-    (0x0FF3F, (0xFE7, 0x1)),
-    (0x03349, (0x7AA, 0x2)),
-    (0x1D5F7, (0x12C6, 0x1)),
-    (0x1D599, (0x1268, 0x1)),
-    (0x1D558, (0x1227, 0x1)),
-    (0x1D5B8, (0x1287, 0x1)),
-    (0x02F07, (0x360, 0x1)),
-    (0x03381, (0x849, 0x2)),
-    (0x0FC47, (0xB04, 0x2)),
-    (0x0330C, (0x6B5, 0x4)),
-    (0x02169, (0x1F7, 0x1)),
-    (0x03285, (0x5E6, 0x1)),
-    (0x1D612, (0x12E1, 0x1)),
-    (0x0FB55, (0x9BE, 0x1)),
-    (0x1D68B, (0x135A, 0x1)),
-    (0x1D798, (0x1465, 0x1)),
-    (0x033F0, (0x956, 0x3)),
-    (0x0FEBA, (0xF58, 0x1)),
-    (0x1D4B1, (0x118F, 0x1)),
-    (0x0FF99, (0x1041, 0x1)),
-    (0x02159, (0x1CF, 0x3)),
-    (0x0FF39, (0xFE1, 0x1)),
-    (0x1D5F0, (0x12BF, 0x1)),
-    (0x1D480, (0x1166, 0x1)),
-    (0x0FEEB, (0xF89, 0x1)),
-    (0x1EE8E, (0x156F, 0x1)),
-    (0x02128, (0x199, 0x1)),
-    (0x1E036, (0x14D1, 0x1)),
-    (0x0FEFB, (0xFA5, 0x2)),
-    (0x1D6DB, (0x13A8, 0x1)),
-    (0x1D6EA, (0x13B7, 0x1)),
-    (0x0FEC6, (0xF64, 0x1)),
-    (0x1EE6C, (0x1552, 0x1)),
-    (0x024C1, (0x31E, 0x1)),
-    (0x1D6B3, (0x1380, 0x1)),
-    (0x1D713, (0x13E0, 0x1)),
-    (0x0FE8C, (0xF29, 0x2)),
-    (0x0FCC2, (0xC0B, 0x2)),
-    (0x024E5, (0x342, 0x1)),
-    (0x0FCC7, (0xC15, 0x2)),
-    (0x00133, (0x01A, 0x2)),
-    (0x1D640, (0x130F, 0x1)),
-    (0x0FFCB, (0x106E, 0x1)),
-    (0x0FDAD, (0xE19, 0x3)),
-    (0x1D57E, (0x124D, 0x1)),
-    (0x1D757, (0x1424, 0x1)),
-    (0x032D3, (0x658, 0x1)),
-    (0x02F76, (0x3CF, 0x1)),
-    (0x02465, (0x231, 0x1)),
-    (0x1EE1C, (0x1524, 0x1)),
-    (0x032D5, (0x65A, 0x1)),
-    (0x0FD73, (0xD71, 0x3)),
-    (0x0FBB0, (0xA1B, 0x2)),
-    (0x02F66, (0x3BF, 0x1)),
-    (0x1D5F6, (0x12C5, 0x1)),
-    (0x0FEBB, (0xF59, 0x1)),
-    (0x002B1, (0x03F, 0x1)),
-    (0x1EE2E, (0x1531, 0x1)),
-    (0x02071, (0x142, 0x1)),
-    (0x0FDFB, (0xEA1, 0x8)),
-    (0x0FC81, (0xB84, 0x2)),
-    (0x0FEEF, (0xF8D, 0x1)),
-    (0x02173, (0x207, 0x2)),
-    (0x1EEA6, (0x1581, 0x1)),
-    (0x02478, (0x257, 0x3)),
-    (0x1D6F8, (0x13C5, 0x1)),
-    (0x1EEAD, (0x1587, 0x1)),
-    (0x1D5BC, (0x128B, 0x1)),
-    (0x1D6AE, (0x137B, 0x1)),
-    (0x0FEDF, (0xF7D, 0x1)),
-    (0x1D5BE, (0x128D, 0x1)),
-    (0x1D672, (0x1341, 0x1)),
-    (0x0FD25, (0xCD6, 0x2)),
-    (0x01DBA, (0x0E4, 0x1)),
-    (0x02463, (0x22F, 0x1)),
-    (0x0FCE2, (0xC4D, 0x2)),
-    (0x0215B, (0x1D5, 0x3)),
-    (0x1D7F9, (0x14C4, 0x1)),
-    (0x032D7, (0x65C, 0x1)),
-    (0x1D4AF, (0x118D, 0x1)),
-    (0x02F91, (0x3EA, 0x1)),
-    (0x0246B, (0x239, 0x2)),
-    (0x107AD, (0x10B6, 0x1)),
-    (0x003D1, (0x060, 0x1)),
-    (0x0FFCC, (0x106F, 0x1)),
-    (0x0FD9E, (0xDEC, 0x3)),
-    (0x02115, (0x189, 0x1)),
-    (0x1D715, (0x13E2, 0x1)),
-    (0x1D5DB, (0x12AA, 0x1)),
-    (0x1D774, (0x1441, 0x1)),
-    (0x0FC61, (0xB3B, 0x3)),
-    (0x1D401, (0x10E8, 0x1)),
-    (0x03309, (0x6AC, 0x3)),
-    (0x1EE68, (0x154F, 0x1)),
-    (0x1EE49, (0x153E, 0x1)),
-    (0x02119, (0x18C, 0x1)),
-    (0x0FB82, (0x9EB, 0x1)),
-    (0x1D642, (0x1311, 0x1)),
-    (0x0FC97, (0xBB0, 0x3)),
-    (0x107B7, (0x10BF, 0x1)),
-    (0x0FB9A, (0xA03, 0x1)),
-    (0x0FFC6, (0x106B, 0x1)),
-    (0x03265, (0x5B1, 0x1)),
-    (0x0333A, (0x771, 0x4)),
-    (0x1D61D, (0x12EC, 0x1)),
-    (0x02F53, (0x3AC, 0x1)),
-    (0x02082, (0x151, 0x1)),
-    (0x1D734, (0x1401, 0x1)),
-    (0x02106, (0x179, 0x3)),
-    (0x10792, (0x109B, 0x1)),
-    (0x1D61B, (0x12EA, 0x1)),
-    (0x1D513, (0x11EB, 0x1)),
-    (0x0FFA1, (0x1049, 0x1)),
-    (0x0FE12, (0xEAF, 0x1)),
-    (0x0FDA2, (0xDF8, 0x3)),
-    (0x0FC91, (0xBA4, 0x2)),
-    (0x01FED, (0x109, 0x3)),
-    (0x1D5DF, (0x12AE, 0x1)),
-    (0x032F8, (0x67D, 0x1)),
-    (0x02FB2, (0x40B, 0x1)),
-    (0x032C4, (0x638, 0x2)),
-    (0x03158, (0x463, 0x1)),
-    (0x1D6D3, (0x13A0, 0x1)),
-    (0x0FB84, (0x9ED, 0x1)),
-    (0x024CA, (0x327, 0x1)),
-    (0x03208, (0x4C0, 0x3)),
-    (0x032FC, (0x681, 0x1)),
-    (0x0FE94, (0xF32, 0x1)),
-    (0x02157, (0x1C9, 0x3)),
-    (0x03357, (0x7DF, 0x3)),
-    (0x0320A, (0x4C6, 0x3)),
-    (0x024DA, (0x337, 0x1)),
-    (0x0FDC2, (0xE58, 0x3)),
-    (0x1D617, (0x12E6, 0x1)),
-    (0x1D5E1, (0x12B0, 0x1)),
-    (0x1D570, (0x123F, 0x1)),
-    (0x0327E, (0x5DF, 0x2)),
-    (0x01FDD, (0x100, 0x3)),
-    (0x0FD5D, (0xD2F, 0x3)),
-    (0x02F83, (0x3DC, 0x1)),
-    (0x0FFE4, (0x1081, 0x1)),
-    (0x0FD87, (0xDAD, 0x3)),
-    (0x024D1, (0x32E, 0x1)),
-    (0x00384, (0x05A, 0x2)),
-    (0x024D6, (0x333, 0x1)),
-    (0x1EE47, (0x153D, 0x1)),
-    (0x003D3, (0x062, 0x2)),
-    (0x032F7, (0x67C, 0x1)),
-    (0x1D609, (0x12D8, 0x1)),
-    (0x024AC, (0x2F5, 0x3)),
-    (0x02F39, (0x392, 0x1)),
-    (0x0FBD7, (0xA23, 0x1)),
-    (0x0FB6F, (0x9D8, 0x1)),
-    (0x0FD13, (0xCB2, 0x2)),
-    (0x0320F, (0x4D6, 0x4)),
-    (0x0FCEE, (0xC65, 0x2)),
-    (0x1D52D, (0x1203, 0x1)),
-    (0x1D62E, (0x12FD, 0x1)),
-    (0x02FAD, (0x406, 0x1)),
-    (0x1D414, (0x10FB, 0x1)),
-    (0x0FE84, (0xF19, 0x2)),
-    (0x1D76D, (0x143A, 0x1)),
-    (0x1F223, (0x164B, 0x1)),
-    (0x02F87, (0x3E0, 0x1)),
-    (0x02FD2, (0x42B, 0x1)),
-    (0x0FF95, (0x103D, 0x1)),
-    (0x1EE02, (0x150B, 0x1)),
-    (0x02471, (0x245, 0x2)),
-    (0x1D714, (0x13E1, 0x1)),
-    (0x1D718, (0x13E5, 0x1)),
-    (0x0FFCE, (0x1071, 0x1)),
-    (0x002B0, (0x03E, 0x1)),
-    (0x1EE57, (0x1546, 0x1)),
-    (0x01DB1, (0x0DB, 0x1)),
-    (0x0FBE3, (0xA30, 0x1)),
-    (0x1E058, (0x14F3, 0x1)),
-    (0x03153, (0x45E, 0x1)),
-    (0x0FF52, (0xFFA, 0x1)),
-    (0x03243, (0x584, 0x3)),
-    (0x03226, (0x52D, 0x3)),
-    (0x0FB6A, (0x9D3, 0x1)),
-    (0x1EE74, (0x1559, 0x1)),
-    (0x032DC, (0x661, 0x1)),
-    (0x0FC03, (0xA7A, 0x3)),
-    (0x01E9B, (0x0EC, 0x2)),
-    (0x0FDA7, (0xE07, 0x3)),
-    (0x0FD15, (0xCB6, 0x2)),
-    (0x0FC01, (0xA74, 0x3)),
-    (0x0FC7C, (0xB7A, 0x2)),
-    (0x03341, (0x78E, 0x3)),
-    (0x03324, (0x71C, 0x4)),
-    (0x02FA8, (0x401, 0x1)),
-    (0x02F3E, (0x397, 0x1)),
-    (0x0FF9C, (0x1044, 0x1)),
-    (0x0FB20, (0x9AD, 0x1)),
-    (0x02F0D, (0x366, 0x1)),
-    (0x1D5EB, (0x12BA, 0x1)),
-    (0x1D59C, (0x126B, 0x1)),
-    (0x0017F, (0x022, 0x1)),
-    (0x1D79E, (0x146B, 0x1)),
-    (0x1EE14, (0x151C, 0x1)),
-    (0x0FD8C, (0xDBC, 0x3)),
-    (0x0FCBD, (0xC01, 0x2)),
-    (0x1F221, (0x1649, 0x1)),
-    (0x02049, (0x13A, 0x2)),
-    (0x1D4D9, (0x11B4, 0x1)),
-    (0x0FDAA, (0xE10, 0x3)),
-    (0x0320E, (0x4D2, 0x4)),
-    (0x1EE39, (0x153A, 0x1)),
-    (0x1D72A, (0x13F7, 0x1)),
-    (0x032AF, (0x610, 0x1)),
-    (0x0FB8E, (0x9F7, 0x1)),
-    (0x02077, (0x146, 0x1)),
-    (0x1D4A6, (0x1187, 0x1)),
-    (0x02F70, (0x3C9, 0x1)),
-    (0x03368, (0x808, 0x3)),
-    (0x0FB6D, (0x9D6, 0x1)),
-    (0x02F5C, (0x3B5, 0x1)),
-    (0x03134, (0x43F, 0x1)),
-    (0x024B6, (0x313, 0x1)),
-    (0x1D630, (0x12FF, 0x1)),
-    (0x033CC, (0x8FF, 0x2)),
-    (0x0FB92, (0x9FB, 0x1)),
-    (0x024D4, (0x331, 0x1)),
-    (0x1D46A, (0x1150, 0x1)),
-    (0x0FF30, (0xFD8, 0x1)),
-    (0x0FC08, (0xA86, 0x2)),
-    (0x0FFB2, (0x105A, 0x1)),
-    (0x033FF, (0x983, 0x3)),
-    (0x0217B, (0x218, 0x3)),
-    (0x0FEDE, (0xF7C, 0x1)),
-    (0x02004, (0x117, 0x1)),
-    (0x0FCD1, (0xC29, 0x2)),
-    (0x0207D, (0x14C, 0x1)),
-    (0x0FB94, (0x9FD, 0x1)),
-    (0x02078, (0x147, 0x1)),
-    (0x1D4DE, (0x11B9, 0x1)),
-    (0x0FC06, (0xA82, 0x2)),
-    (0x1D5AB, (0x127A, 0x1)),
-    (0x1D6EB, (0x13B8, 0x1)),
-    (0x0FF79, (0x1021, 0x1)),
-    (0x1D705, (0x13D2, 0x1)),
-    (0x02462, (0x22E, 0x1)),
-    (0x0FCA1, (0xBC9, 0x2)),
-    (0x0FC28, (0xAC6, 0x2)),
-    (0x1D77E, (0x144B, 0x1)),
-    (0x0FEE6, (0xF84, 0x1)),
-    (0x1F127, (0x15F1, 0x3)),
-    (0x1D580, (0x124F, 0x1)),
-    (0x1EE4F, (0x1542, 0x1)),
-    (0x1D619, (0x12E8, 0x1)),
-    (0x0323B, (0x56C, 0x3)),
-    (0x001C8, (0x02E, 0x2)),
-    (0x1F21C, (0x1644, 0x1)),
-    (0x1FBF2, (0x1683, 0x1)),
-    (0x0FB26, (0x9B3, 0x1)),
-    (0x1E03B, (0x14D6, 0x1)),
-    (0x0FDB8, (0xE3A, 0x3)),
-    (0x1D54F, (0x121F, 0x1)),
-    (0x1D564, (0x1233, 0x1)),
-    (0x1D7EB, (0x14B6, 0x1)),
-    (0x1E050, (0x14EB, 0x1)),
-    (0x1D5D8, (0x12A7, 0x1)),
-    (0x1D4F0, (0x11CB, 0x1)),
-    (0x0FFD3, (0x1074, 0x1)),
-    (0x032DE, (0x663, 0x1)),
-    (0x1D574, (0x1243, 0x1)),
-    (0x002E4, (0x057, 0x1)),
-    (0x1D59E, (0x126D, 0x1)),
-    (0x0FF74, (0x101C, 0x1)),
-    (0x0215E, (0x1DE, 0x3)),
-    (0x0FD34, (0xCF4, 0x2)),
-    (0x0FF2A, (0xFD2, 0x1)),
-    (0x0FF15, (0xFBD, 0x1)),
-    (0x1D50D, (0x11E5, 0x1)),
-    (0x0FC21, (0xAB8, 0x2)),
-    (0x0FF4F, (0xFF7, 0x1)),
-    (0x0FEA1, (0xF3F, 0x1)),
-    (0x1D60D, (0x12DC, 0x1)),
-    (0x0FF3A, (0xFE2, 0x1)),
-    (0x1EE12, (0x151A, 0x1)),
-    (0x03318, (0x6EA, 0x4)),
-    (0x0FE7C, (0xF0A, 0x2)),
-    (0x0FCAB, (0xBDD, 0x2)),
-    (0x03205, (0x4B7, 0x3)),
-    (0x001F1, (0x038, 0x2)),
-    (0x0FE42, (0xECC, 0x1)),
-    (0x0FE91, (0xF2F, 0x1)),
-    (0x001C7, (0x02C, 0x2)),
-    (0x1D681, (0x1350, 0x1)),
-    (0x1D6DE, (0x13AB, 0x1)),
-    (0x1D4B0, (0x118E, 0x1)),
-    (0x1D742, (0x140F, 0x1)),
-    (0x1D67F, (0x134E, 0x1)),
-    (0x1D645, (0x1314, 0x1)),
-    (0x0FEB0, (0xF4E, 0x1)),
-    (0x1F121, (0x15DF, 0x3)),
-    (0x1D611, (0x12E0, 0x1)),
-    (0x1D752, (0x141F, 0x1)),
-    (0x0FE32, (0xEBC, 0x1)),
-    (0x0FF81, (0x1029, 0x1)),
-    (0x02009, (0x11C, 0x1)),
-    (0x1F14C, (0x1621, 0x2)),
-    (0x0FEDB, (0xF79, 0x1)),
-    (0x1D5D0, (0x129F, 0x1)),
-    (0x0FCFA, (0xC80, 0x2)),
-    (0x03296, (0x5F7, 0x1)),
-    (0x1D71A, (0x13E7, 0x1)),
-    (0x107A6, (0x10AF, 0x1)),
-    (0x1D5AC, (0x127B, 0x1)),
-    (0x0FD93, (0xDCB, 0x3)),
-    (0x1EE8B, (0x156C, 0x1)),
-    (0x0FECB, (0xF69, 0x1)),
-    (0x1D7A3, (0x1470, 0x1)),
-    (0x02F96, (0x3EF, 0x1)),
-    (0x1EE4E, (0x1541, 0x1)),
-    (0x024CF, (0x32C, 0x1)),
-    (0x032AA, (0x60B, 0x1)),
-    (0x1EE88, (0x156A, 0x1)),
-    (0x03270, (0x5BE, 0x2)),
-    (0x0FCEB, (0xC5F, 0x2)),
-    (0x032E0, (0x665, 0x1)),
-    (0x1D587, (0x1256, 0x1)),
-    (0x1CCEC, (0x10D9, 0x1)),
-    (0x1D7C8, (0x1495, 0x1)),
-    (0x0FEB2, (0xF50, 0x1)),
-    (0x03379, (0x836, 0x3)),
-    (0x1D688, (0x1357, 0x1)),
-    (0x107B2, (0x10BA, 0x1)),
-    (0x033C8, (0x8F7, 0x2)),
-    (0x1D620, (0x12EF, 0x1)),
-    (0x0FC3D, (0xAF0, 0x2)),
-    (0x0FDA9, (0xE0D, 0x3)),
-    (0x1F246, (0x1676, 0x3)),
-    (0x0FEF9, (0xF9F, 0x3)),
-    (0x02160, (0x1E3, 0x1)),
-    (0x1D72F, (0x13FC, 0x1)),
-    (0x0FC73, (0xB68, 0x2)),
-    (0x02481, (0x276, 0x4)),
-    (0x1D528, (0x11FE, 0x1)),
-    (0x0327D, (0x5DB, 0x4)),
-    (0x0FB60, (0x9C9, 0x1)),
-    (0x033B3, (0x8C8, 0x2)),
-    (0x02F37, (0x390, 0x1)),
-    (0x1D54D, (0x121D, 0x1)),
-    (0x0FC33, (0xADC, 0x2)),
-    (0x032B3, (0x616, 0x2)),
-    (0x1D41B, (0x1102, 0x1)),
-    (0x1D475, (0x115B, 0x1)),
-    (0x0216D, (0x1FE, 0x1)),
-    (0x0FEB4, (0xF52, 0x1)),
-    (0x1D41D, (0x1104, 0x1)),
-    (0x1EE0C, (0x1514, 0x1)),
-    (0x0FEB6, (0xF54, 0x1)),
-    (0x1E05D, (0x14F8, 0x1)),
-    (0x0FF26, (0xFCE, 0x1)),
-    (0x1D592, (0x1261, 0x1)),
-    (0x0212F, (0x19C, 0x1)),
-    (0x0FC18, (0xAA6, 0x2)),
-    (0x0FDF3, (0xE74, 0x4)),
-    (0x033F1, (0x959, 0x3)),
-    (0x0FCB6, (0xBF3, 0x2)),
-    (0x032B9, (0x622, 0x2)),
-    (0x0FB79, (0x9E2, 0x1)),
-    (0x1D4B6, (0x1194, 0x1)),
-    (0x0FEF0, (0xF8E, 0x1)),
-    (0x033B7, (0x8D0, 0x2)),
-    (0x0FB7B, (0x9E4, 0x1)),
-    (0x1D55A, (0x1229, 0x1)),
-    (0x0FCB1, (0xBE9, 0x2)),
-    (0x02472, (0x247, 0x2)),
-    (0x0321C, (0x50A, 0x4)),
-    (0x002B2, (0x040, 0x1)),
-    (0x02F0E, (0x367, 0x1)),
-    (0x0FF89, (0x1031, 0x1)),
-    (0x1D6F5, (0x13C2, 0x1)),
-];
-pub(crate) const CJK_COMPAT_VARIANTS_DECOMPOSED_CHARS: &[char] = &[
-    '\u{349E}',
-    '\u{FE00}',
-    '\u{34B9}',
-    '\u{FE00}',
-    '\u{34BB}',
-    '\u{FE00}',
-    '\u{34DF}',
-    '\u{FE00}',
-    '\u{3515}',
-    '\u{FE00}',
-    '\u{36EE}',
-    '\u{FE00}',
-    '\u{36FC}',
-    '\u{FE00}',
-    '\u{3781}',
-    '\u{FE00}',
-    '\u{382F}',
-    '\u{FE00}',
-    '\u{3862}',
-    '\u{FE00}',
-    '\u{387C}',
-    '\u{FE00}',
-    '\u{38C7}',
-    '\u{FE00}',
-    '\u{38E3}',
-    '\u{FE00}',
-    '\u{391C}',
-    '\u{FE00}',
-    '\u{393A}',
-    '\u{FE00}',
-    '\u{3A2E}',
-    '\u{FE00}',
-    '\u{3A6C}',
-    '\u{FE00}',
-    '\u{3AE4}',
-    '\u{FE00}',
-    '\u{3B08}',
-    '\u{FE00}',
-    '\u{3B19}',
-    '\u{FE00}',
-    '\u{3B49}',
-    '\u{FE00}',
-    '\u{3B9D}',
-    '\u{FE00}',
-    '\u{3B9D}',
-    '\u{FE01}',
-    '\u{3C18}',
-    '\u{FE00}',
-    '\u{3C4E}',
-    '\u{FE00}',
-    '\u{3D33}',
-    '\u{FE00}',
-    '\u{3D96}',
-    '\u{FE00}',
-    '\u{3EAC}',
-    '\u{FE00}',
-    '\u{3EB8}',
-    '\u{FE00}',
-    '\u{3EB8}',
-    '\u{FE01}',
-    '\u{3F1B}',
-    '\u{FE00}',
-    '\u{3FFC}',
-    '\u{FE00}',
-    '\u{4008}',
-    '\u{FE00}',
-    '\u{4018}',
-    '\u{FE00}',
-    '\u{4039}',
-    '\u{FE00}',
-    '\u{4039}',
-    '\u{FE01}',
-    '\u{4046}',
-    '\u{FE00}',
-    '\u{4096}',
-    '\u{FE00}',
-    '\u{40E3}',
-    '\u{FE00}',
-    '\u{412F}',
-    '\u{FE00}',
-    '\u{4202}',
-    '\u{FE00}',
-    '\u{4227}',
-    '\u{FE00}',
-    '\u{42A0}',
-    '\u{FE00}',
-    '\u{4301}',
-    '\u{FE00}',
-    '\u{4334}',
-    '\u{FE00}',
-    '\u{4359}',
-    '\u{FE00}',
-    '\u{43D5}',
-    '\u{FE00}',
-    '\u{43D9}',
-    '\u{FE00}',
-    '\u{440B}',
-    '\u{FE00}',
-    '\u{446B}',
-    '\u{FE00}',
-    '\u{452B}',
-    '\u{FE00}',
-    '\u{455D}',
-    '\u{FE00}',
-    '\u{4561}',
-    '\u{FE00}',
-    '\u{456B}',
-    '\u{FE00}',
-    '\u{45D7}',
-    '\u{FE00}',
-    '\u{45F9}',
-    '\u{FE00}',
-    '\u{4635}',
-    '\u{FE00}',
-    '\u{46BE}',
-    '\u{FE00}',
-    '\u{46C7}',
-    '\u{FE00}',
-    '\u{4995}',
-    '\u{FE00}',
-    '\u{49E6}',
-    '\u{FE00}',
-    '\u{4A6E}',
-    '\u{FE00}',
-    '\u{4A76}',
-    '\u{FE00}',
-    '\u{4AB2}',
-    '\u{FE00}',
-    '\u{4B33}',
-    '\u{FE00}',
-    '\u{4BCE}',
-    '\u{FE00}',
-    '\u{4CCE}',
-    '\u{FE00}',
-    '\u{4CED}',
-    '\u{FE00}',
-    '\u{4CF8}',
-    '\u{FE00}',
-    '\u{4D56}',
-    '\u{FE00}',
-    '\u{4E0D}',
-    '\u{FE00}',
-    '\u{4E26}',
-    '\u{FE00}',
-    '\u{4E32}',
-    '\u{FE00}',
-    '\u{4E38}',
-    '\u{FE00}',
-    '\u{4E39}',
-    '\u{FE00}',
-    '\u{4E3D}',
-    '\u{FE00}',
-    '\u{4E41}',
-    '\u{FE00}',
-    '\u{4E82}',
-    '\u{FE00}',
-    '\u{4E86}',
-    '\u{FE00}',
-    '\u{4EAE}',
-    '\u{FE00}',
-    '\u{4EC0}',
-    '\u{FE00}',
-    '\u{4ECC}',
-    '\u{FE00}',
-    '\u{4EE4}',
-    '\u{FE00}',
-    '\u{4F60}',
-    '\u{FE00}',
-    '\u{4F80}',
-    '\u{FE00}',
-    '\u{4F86}',
-    '\u{FE00}',
-    '\u{4F8B}',
-    '\u{FE00}',
-    '\u{4FAE}',
-    '\u{FE00}',
-    '\u{4FAE}',
-    '\u{FE01}',
-    '\u{4FBB}',
-    '\u{FE00}',
-    '\u{4FBF}',
-    '\u{FE00}',
-    '\u{5002}',
-    '\u{FE00}',
-    '\u{502B}',
-    '\u{FE00}',
-    '\u{507A}',
-    '\u{FE00}',
-    '\u{5099}',
-    '\u{FE00}',
-    '\u{50CF}',
-    '\u{FE00}',
-    '\u{50DA}',
-    '\u{FE00}',
-    '\u{50E7}',
-    '\u{FE00}',
-    '\u{50E7}',
-    '\u{FE01}',
-    '\u{5140}',
-    '\u{FE00}',
-    '\u{5145}',
-    '\u{FE00}',
-    '\u{514D}',
-    '\u{FE00}',
-    '\u{514D}',
-    '\u{FE01}',
-    '\u{5154}',
-    '\u{FE00}',
-    '\u{5164}',
-    '\u{FE00}',
-    '\u{5167}',
-    '\u{FE00}',
-    '\u{5168}',
-    '\u{FE00}',
-    '\u{5169}',
-    '\u{FE00}',
-    '\u{516D}',
-    '\u{FE00}',
-    '\u{5177}',
-    '\u{FE00}',
-    '\u{5180}',
-    '\u{FE00}',
-    '\u{518D}',
-    '\u{FE00}',
-    '\u{5192}',
-    '\u{FE00}',
-    '\u{5195}',
-    '\u{FE00}',
-    '\u{5197}',
-    '\u{FE00}',
-    '\u{51A4}',
-    '\u{FE00}',
-    '\u{51AC}',
-    '\u{FE00}',
-    '\u{51B5}',
-    '\u{FE00}',
-    '\u{51B5}',
-    '\u{FE01}',
-    '\u{51B7}',
-    '\u{FE00}',
-    '\u{51C9}',
-    '\u{FE00}',
-    '\u{51CC}',
-    '\u{FE00}',
-    '\u{51DC}',
-    '\u{FE00}',
-    '\u{51DE}',
-    '\u{FE00}',
-    '\u{51F5}',
-    '\u{FE00}',
-    '\u{5203}',
-    '\u{FE00}',
-    '\u{5207}',
-    '\u{FE00}',
-    '\u{5207}',
-    '\u{FE01}',
-    '\u{5217}',
-    '\u{FE00}',
-    '\u{5229}',
-    '\u{FE00}',
-    '\u{523A}',
-    '\u{FE00}',
-    '\u{523B}',
-    '\u{FE00}',
-    '\u{5246}',
-    '\u{FE00}',
-    '\u{5272}',
-    '\u{FE00}',
-    '\u{5277}',
-    '\u{FE00}',
-    '\u{5289}',
-    '\u{FE00}',
-    '\u{529B}',
-    '\u{FE00}',
-    '\u{52A3}',
-    '\u{FE00}',
-    '\u{52B3}',
-    '\u{FE00}',
-    '\u{52C7}',
-    '\u{FE00}',
-    '\u{52C7}',
-    '\u{FE01}',
-    '\u{52C9}',
-    '\u{FE00}',
-    '\u{52C9}',
-    '\u{FE01}',
-    '\u{52D2}',
-    '\u{FE00}',
-    '\u{52DE}',
-    '\u{FE00}',
-    '\u{52E4}',
-    '\u{FE00}',
-    '\u{52E4}',
-    '\u{FE01}',
-    '\u{52F5}',
-    '\u{FE00}',
-    '\u{52FA}',
-    '\u{FE00}',
-    '\u{52FA}',
-    '\u{FE01}',
-    '\u{5305}',
-    '\u{FE00}',
-    '\u{5306}',
-    '\u{FE00}',
-    '\u{5317}',
-    '\u{FE00}',
-    '\u{5317}',
-    '\u{FE01}',
-    '\u{533F}',
-    '\u{FE00}',
-    '\u{5349}',
-    '\u{FE00}',
-    '\u{5351}',
-    '\u{FE00}',
-    '\u{5351}',
-    '\u{FE01}',
-    '\u{535A}',
-    '\u{FE00}',
-    '\u{5373}',
-    '\u{FE00}',
-    '\u{5375}',
-    '\u{FE00}',
-    '\u{537D}',
-    '\u{FE00}',
-    '\u{537F}',
-    '\u{FE00}',
-    '\u{537F}',
-    '\u{FE01}',
-    '\u{537F}',
-    '\u{FE02}',
-    '\u{53C3}',
-    '\u{FE00}',
-    '\u{53CA}',
-    '\u{FE00}',
-    '\u{53DF}',
-    '\u{FE00}',
-    '\u{53E5}',
-    '\u{FE00}',
-    '\u{53EB}',
-    '\u{FE00}',
-    '\u{53F1}',
-    '\u{FE00}',
-    '\u{5406}',
-    '\u{FE00}',
-    '\u{540F}',
-    '\u{FE00}',
-    '\u{541D}',
-    '\u{FE00}',
-    '\u{5438}',
-    '\u{FE00}',
-    '\u{5442}',
-    '\u{FE00}',
-    '\u{5448}',
-    '\u{FE00}',
-    '\u{5468}',
-    '\u{FE00}',
-    '\u{549E}',
-    '\u{FE00}',
-    '\u{54A2}',
-    '\u{FE00}',
-    '\u{54BD}',
-    '\u{FE00}',
-    '\u{54F6}',
-    '\u{FE00}',
-    '\u{5510}',
-    '\u{FE00}',
-    '\u{5553}',
-    '\u{FE00}',
-    '\u{5555}',
-    '\u{FE00}',
-    '\u{5563}',
-    '\u{FE00}',
-    '\u{5584}',
-    '\u{FE00}',
-    '\u{5584}',
-    '\u{FE01}',
-    '\u{5587}',
-    '\u{FE00}',
-    '\u{5599}',
-    '\u{FE00}',
-    '\u{5599}',
-    '\u{FE01}',
-    '\u{559D}',
-    '\u{FE00}',
-    '\u{559D}',
-    '\u{FE01}',
-    '\u{55AB}',
-    '\u{FE00}',
-    '\u{55B3}',
-    '\u{FE00}',
-    '\u{55C0}',
-    '\u{FE00}',
-    '\u{55C2}',
-    '\u{FE00}',
-    '\u{55E2}',
-    '\u{FE00}',
-    '\u{5606}',
-    '\u{FE00}',
-    '\u{5606}',
-    '\u{FE01}',
-    '\u{5651}',
-    '\u{FE00}',
-    '\u{5668}',
-    '\u{FE00}',
-    '\u{5674}',
-    '\u{FE00}',
-    '\u{56F9}',
-    '\u{FE00}',
-    '\u{5716}',
-    '\u{FE00}',
-    '\u{5717}',
-    '\u{FE00}',
-    '\u{578B}',
-    '\u{FE00}',
-    '\u{57CE}',
-    '\u{FE00}',
-    '\u{57F4}',
-    '\u{FE00}',
-    '\u{580D}',
-    '\u{FE00}',
-    '\u{5831}',
-    '\u{FE00}',
-    '\u{5832}',
-    '\u{FE00}',
-    '\u{5840}',
-    '\u{FE00}',
-    '\u{585A}',
-    '\u{FE00}',
-    '\u{585A}',
-    '\u{FE01}',
-    '\u{585E}',
-    '\u{FE00}',
-    '\u{58A8}',
-    '\u{FE00}',
-    '\u{58AC}',
-    '\u{FE00}',
-    '\u{58B3}',
-    '\u{FE00}',
-    '\u{58D8}',
-    '\u{FE00}',
-    '\u{58DF}',
-    '\u{FE00}',
-    '\u{58EE}',
-    '\u{FE00}',
-    '\u{58F2}',
-    '\u{FE00}',
-    '\u{58F7}',
-    '\u{FE00}',
-    '\u{5906}',
-    '\u{FE00}',
-    '\u{591A}',
-    '\u{FE00}',
-    '\u{5922}',
-    '\u{FE00}',
-    '\u{5944}',
-    '\u{FE00}',
-    '\u{5948}',
-    '\u{FE00}',
-    '\u{5951}',
-    '\u{FE00}',
-    '\u{5954}',
-    '\u{FE00}',
-    '\u{5962}',
-    '\u{FE00}',
-    '\u{5973}',
-    '\u{FE00}',
-    '\u{59D8}',
-    '\u{FE00}',
-    '\u{59EC}',
-    '\u{FE00}',
-    '\u{5A1B}',
-    '\u{FE00}',
-    '\u{5A27}',
-    '\u{FE00}',
-    '\u{5A62}',
-    '\u{FE00}',
-    '\u{5A66}',
-    '\u{FE00}',
-    '\u{5AB5}',
-    '\u{FE00}',
-    '\u{5B08}',
-    '\u{FE00}',
-    '\u{5B28}',
-    '\u{FE00}',
-    '\u{5B3E}',
-    '\u{FE00}',
-    '\u{5B3E}',
-    '\u{FE01}',
-    '\u{5B85}',
-    '\u{FE00}',
-    '\u{5BC3}',
-    '\u{FE00}',
-    '\u{5BD8}',
-    '\u{FE00}',
-    '\u{5BE7}',
-    '\u{FE00}',
-    '\u{5BE7}',
-    '\u{FE01}',
-    '\u{5BE7}',
-    '\u{FE02}',
-    '\u{5BEE}',
-    '\u{FE00}',
-    '\u{5BF3}',
-    '\u{FE00}',
-    '\u{5BFF}',
-    '\u{FE00}',
-    '\u{5C06}',
-    '\u{FE00}',
-    '\u{5C22}',
-    '\u{FE00}',
-    '\u{5C3F}',
-    '\u{FE00}',
-    '\u{5C60}',
-    '\u{FE00}',
-    '\u{5C62}',
-    '\u{FE00}',
-    '\u{5C64}',
-    '\u{FE00}',
-    '\u{5C65}',
-    '\u{FE00}',
-    '\u{5C6E}',
-    '\u{FE00}',
-    '\u{5C6E}',
-    '\u{FE01}',
-    '\u{5C8D}',
-    '\u{FE00}',
-    '\u{5CC0}',
-    '\u{FE00}',
-    '\u{5D19}',
-    '\u{FE00}',
-    '\u{5D43}',
-    '\u{FE00}',
-    '\u{5D50}',
-    '\u{FE00}',
-    '\u{5D6B}',
-    '\u{FE00}',
-    '\u{5D6E}',
-    '\u{FE00}',
-    '\u{5D7C}',
-    '\u{FE00}',
-    '\u{5DB2}',
-    '\u{FE00}',
-    '\u{5DBA}',
-    '\u{FE00}',
-    '\u{5DE1}',
-    '\u{FE00}',
-    '\u{5DE2}',
-    '\u{FE00}',
-    '\u{5DFD}',
-    '\u{FE00}',
-    '\u{5E28}',
-    '\u{FE00}',
-    '\u{5E3D}',
-    '\u{FE00}',
-    '\u{5E69}',
-    '\u{FE00}',
-    '\u{5E74}',
-    '\u{FE00}',
-    '\u{5EA6}',
-    '\u{FE00}',
-    '\u{5EB0}',
-    '\u{FE00}',
-    '\u{5EB3}',
-    '\u{FE00}',
-    '\u{5EB6}',
-    '\u{FE00}',
-    '\u{5EC9}',
-    '\u{FE00}',
-    '\u{5ECA}',
-    '\u{FE00}',
-    '\u{5ECA}',
-    '\u{FE01}',
-    '\u{5ED2}',
-    '\u{FE00}',
-    '\u{5ED3}',
-    '\u{FE00}',
-    '\u{5ED9}',
-    '\u{FE00}',
-    '\u{5EEC}',
-    '\u{FE00}',
-    '\u{5EFE}',
-    '\u{FE00}',
-    '\u{5F04}',
-    '\u{FE00}',
-    '\u{5F22}',
-    '\u{FE00}',
-    '\u{5F22}',
-    '\u{FE01}',
-    '\u{5F53}',
-    '\u{FE00}',
-    '\u{5F62}',
-    '\u{FE00}',
-    '\u{5F69}',
-    '\u{FE00}',
-    '\u{5F6B}',
-    '\u{FE00}',
-    '\u{5F8B}',
-    '\u{FE00}',
-    '\u{5F9A}',
-    '\u{FE00}',
-    '\u{5FA9}',
-    '\u{FE00}',
-    '\u{5FAD}',
-    '\u{FE00}',
-    '\u{5FCD}',
-    '\u{FE00}',
-    '\u{5FD7}',
-    '\u{FE00}',
-    '\u{5FF5}',
-    '\u{FE00}',
-    '\u{5FF9}',
-    '\u{FE00}',
-    '\u{6012}',
-    '\u{FE00}',
-    '\u{601C}',
-    '\u{FE00}',
-    '\u{6075}',
-    '\u{FE00}',
-    '\u{6081}',
-    '\u{FE00}',
-    '\u{6094}',
-    '\u{FE00}',
-    '\u{6094}',
-    '\u{FE01}',
-    '\u{60C7}',
-    '\u{FE00}',
-    '\u{60D8}',
-    '\u{FE00}',
-    '\u{60E1}',
-    '\u{FE00}',
-    '\u{6108}',
-    '\u{FE00}',
-    '\u{6144}',
-    '\u{FE00}',
-    '\u{6148}',
-    '\u{FE00}',
-    '\u{614C}',
-    '\u{FE00}',
-    '\u{614C}',
-    '\u{FE01}',
-    '\u{614E}',
-    '\u{FE00}',
-    '\u{614E}',
-    '\u{FE01}',
-    '\u{6160}',
-    '\u{FE00}',
-    '\u{6168}',
-    '\u{FE00}',
-    '\u{617A}',
-    '\u{FE00}',
-    '\u{618E}',
-    '\u{FE00}',
-    '\u{618E}',
-    '\u{FE01}',
-    '\u{618E}',
-    '\u{FE02}',
-    '\u{6190}',
-    '\u{FE00}',
-    '\u{61A4}',
-    '\u{FE00}',
-    '\u{61AF}',
-    '\u{FE00}',
-    '\u{61B2}',
-    '\u{FE00}',
-    '\u{61DE}',
-    '\u{FE00}',
-    '\u{61F2}',
-    '\u{FE00}',
-    '\u{61F2}',
-    '\u{FE01}',
-    '\u{61F2}',
-    '\u{FE02}',
-    '\u{61F6}',
-    '\u{FE00}',
-    '\u{61F6}',
-    '\u{FE01}',
-    '\u{6200}',
-    '\u{FE00}',
-    '\u{6210}',
-    '\u{FE00}',
-    '\u{621B}',
-    '\u{FE00}',
-    '\u{622E}',
-    '\u{FE00}',
-    '\u{6234}',
-    '\u{FE00}',
-    '\u{625D}',
-    '\u{FE00}',
-    '\u{62B1}',
-    '\u{FE00}',
-    '\u{62C9}',
-    '\u{FE00}',
-    '\u{62CF}',
-    '\u{FE00}',
-    '\u{62D3}',
-    '\u{FE00}',
-    '\u{62D4}',
-    '\u{FE00}',
-    '\u{62FC}',
-    '\u{FE00}',
-    '\u{62FE}',
-    '\u{FE00}',
-    '\u{633D}',
-    '\u{FE00}',
-    '\u{6350}',
-    '\u{FE00}',
-    '\u{6368}',
-    '\u{FE00}',
-    '\u{637B}',
-    '\u{FE00}',
-    '\u{6383}',
-    '\u{FE00}',
-    '\u{63A0}',
-    '\u{FE00}',
-    '\u{63A9}',
-    '\u{FE00}',
-    '\u{63C4}',
-    '\u{FE00}',
-    '\u{63C5}',
-    '\u{FE00}',
-    '\u{63E4}',
-    '\u{FE00}',
-    '\u{641C}',
-    '\u{FE00}',
-    '\u{6422}',
-    '\u{FE00}',
-    '\u{6452}',
-    '\u{FE00}',
-    '\u{6469}',
-    '\u{FE00}',
-    '\u{6477}',
-    '\u{FE00}',
-    '\u{647E}',
-    '\u{FE00}',
-    '\u{649A}',
-    '\u{FE00}',
-    '\u{649D}',
-    '\u{FE00}',
-    '\u{64C4}',
-    '\u{FE00}',
-    '\u{654F}',
-    '\u{FE00}',
-    '\u{654F}',
-    '\u{FE01}',
-    '\u{6556}',
-    '\u{FE00}',
-    '\u{656C}',
-    '\u{FE00}',
-    '\u{6578}',
-    '\u{FE00}',
-    '\u{6599}',
-    '\u{FE00}',
-    '\u{65C5}',
-    '\u{FE00}',
-    '\u{65E2}',
-    '\u{FE00}',
-    '\u{65E3}',
-    '\u{FE00}',
-    '\u{6613}',
-    '\u{FE00}',
-    '\u{6649}',
-    '\u{FE00}',
-    '\u{6674}',
-    '\u{FE00}',
-    '\u{6674}',
-    '\u{FE01}',
-    '\u{6688}',
-    '\u{FE00}',
-    '\u{6691}',
-    '\u{FE00}',
-    '\u{6691}',
-    '\u{FE01}',
-    '\u{669C}',
-    '\u{FE00}',
-    '\u{66B4}',
-    '\u{FE00}',
-    '\u{66C6}',
-    '\u{FE00}',
-    '\u{66F4}',
-    '\u{FE00}',
-    '\u{66F8}',
-    '\u{FE00}',
-    '\u{6700}',
-    '\u{FE00}',
-    '\u{6717}',
-    '\u{FE00}',
-    '\u{6717}',
-    '\u{FE01}',
-    '\u{6717}',
-    '\u{FE02}',
-    '\u{671B}',
-    '\u{FE00}',
-    '\u{671B}',
-    '\u{FE01}',
-    '\u{6721}',
-    '\u{FE00}',
-    '\u{674E}',
-    '\u{FE00}',
-    '\u{6753}',
-    '\u{FE00}',
-    '\u{6756}',
-    '\u{FE00}',
-    '\u{675E}',
-    '\u{FE00}',
-    '\u{677B}',
-    '\u{FE00}',
-    '\u{6785}',
-    '\u{FE00}',
-    '\u{6797}',
-    '\u{FE00}',
-    '\u{67F3}',
-    '\u{FE00}',
-    '\u{67FA}',
-    '\u{FE00}',
-    '\u{6817}',
-    '\u{FE00}',
-    '\u{681F}',
-    '\u{FE00}',
-    '\u{6852}',
-    '\u{FE00}',
-    '\u{6881}',
-    '\u{FE00}',
-    '\u{6885}',
-    '\u{FE00}',
-    '\u{6885}',
-    '\u{FE01}',
-    '\u{688E}',
-    '\u{FE00}',
-    '\u{68A8}',
-    '\u{FE00}',
-    '\u{6914}',
-    '\u{FE00}',
-    '\u{6942}',
-    '\u{FE00}',
-    '\u{69A3}',
-    '\u{FE00}',
-    '\u{69EA}',
-    '\u{FE00}',
-    '\u{6A02}',
-    '\u{FE00}',
-    '\u{6A02}',
-    '\u{FE01}',
-    '\u{6A02}',
-    '\u{FE02}',
-    '\u{6A13}',
-    '\u{FE00}',
-    '\u{6AA8}',
-    '\u{FE00}',
-    '\u{6AD3}',
-    '\u{FE00}',
-    '\u{6ADB}',
-    '\u{FE00}',
-    '\u{6B04}',
-    '\u{FE00}',
-    '\u{6B21}',
-    '\u{FE00}',
-    '\u{6B54}',
-    '\u{FE00}',
-    '\u{6B72}',
-    '\u{FE00}',
-    '\u{6B77}',
-    '\u{FE00}',
-    '\u{6B79}',
-    '\u{FE00}',
-    '\u{6B9F}',
-    '\u{FE00}',
-    '\u{6BAE}',
-    '\u{FE00}',
-    '\u{6BBA}',
-    '\u{FE00}',
-    '\u{6BBA}',
-    '\u{FE01}',
-    '\u{6BBA}',
-    '\u{FE02}',
-    '\u{6BBB}',
-    '\u{FE00}',
-    '\u{6C4E}',
-    '\u{FE00}',
-    '\u{6C67}',
-    '\u{FE00}',
-    '\u{6C88}',
-    '\u{FE00}',
-    '\u{6CBF}',
-    '\u{FE00}',
-    '\u{6CCC}',
-    '\u{FE00}',
-    '\u{6CCD}',
-    '\u{FE00}',
-    '\u{6CE5}',
-    '\u{FE00}',
-    '\u{6D16}',
-    '\u{FE00}',
-    '\u{6D1B}',
-    '\u{FE00}',
-    '\u{6D1E}',
-    '\u{FE00}',
-    '\u{6D34}',
-    '\u{FE00}',
-    '\u{6D3E}',
-    '\u{FE00}',
-    '\u{6D41}',
-    '\u{FE00}',
-    '\u{6D41}',
-    '\u{FE01}',
-    '\u{6D41}',
-    '\u{FE02}',
-    '\u{6D69}',
-    '\u{FE00}',
-    '\u{6D6A}',
-    '\u{FE00}',
-    '\u{6D77}',
-    '\u{FE00}',
-    '\u{6D77}',
-    '\u{FE01}',
-    '\u{6D78}',
-    '\u{FE00}',
-    '\u{6D85}',
-    '\u{FE00}',
-    '\u{6DCB}',
-    '\u{FE00}',
-    '\u{6DDA}',
-    '\u{FE00}',
-    '\u{6DEA}',
-    '\u{FE00}',
-    '\u{6DF9}',
-    '\u{FE00}',
-    '\u{6E1A}',
-    '\u{FE00}',
-    '\u{6E2F}',
-    '\u{FE00}',
-    '\u{6E6E}',
-    '\u{FE00}',
-    '\u{6E9C}',
-    '\u{FE00}',
-    '\u{6EBA}',
-    '\u{FE00}',
-    '\u{6EC7}',
-    '\u{FE00}',
-    '\u{6ECB}',
-    '\u{FE00}',
-    '\u{6ECB}',
-    '\u{FE01}',
-    '\u{6ED1}',
-    '\u{FE00}',
-    '\u{6EDB}',
-    '\u{FE00}',
-    '\u{6F0F}',
-    '\u{FE00}',
-    '\u{6F22}',
-    '\u{FE00}',
-    '\u{6F22}',
-    '\u{FE01}',
-    '\u{6F23}',
-    '\u{FE00}',
-    '\u{6F6E}',
-    '\u{FE00}',
-    '\u{6FC6}',
-    '\u{FE00}',
-    '\u{6FEB}',
-    '\u{FE00}',
-    '\u{6FFE}',
-    '\u{FE00}',
-    '\u{701B}',
-    '\u{FE00}',
-    '\u{701E}',
-    '\u{FE00}',
-    '\u{701E}',
-    '\u{FE01}',
-    '\u{7039}',
-    '\u{FE00}',
-    '\u{704A}',
-    '\u{FE00}',
-    '\u{7070}',
-    '\u{FE00}',
-    '\u{7077}',
-    '\u{FE00}',
-    '\u{707D}',
-    '\u{FE00}',
-    '\u{7099}',
-    '\u{FE00}',
-    '\u{70AD}',
-    '\u{FE00}',
-    '\u{70C8}',
-    '\u{FE00}',
-    '\u{70D9}',
-    '\u{FE00}',
-    '\u{7145}',
-    '\u{FE00}',
-    '\u{7149}',
-    '\u{FE00}',
-    '\u{716E}',
-    '\u{FE00}',
-    '\u{716E}',
-    '\u{FE01}',
-    '\u{719C}',
-    '\u{FE00}',
-    '\u{71CE}',
-    '\u{FE00}',
-    '\u{71D0}',
-    '\u{FE00}',
-    '\u{7210}',
-    '\u{FE00}',
-    '\u{721B}',
-    '\u{FE00}',
-    '\u{7228}',
-    '\u{FE00}',
-    '\u{722B}',
-    '\u{FE00}',
-    '\u{7235}',
-    '\u{FE00}',
-    '\u{7235}',
-    '\u{FE01}',
-    '\u{7250}',
-    '\u{FE00}',
-    '\u{7262}',
-    '\u{FE00}',
-    '\u{7280}',
-    '\u{FE00}',
-    '\u{7295}',
-    '\u{FE00}',
-    '\u{72AF}',
-    '\u{FE00}',
-    '\u{72C0}',
-    '\u{FE00}',
-    '\u{72FC}',
-    '\u{FE00}',
-    '\u{732A}',
-    '\u{FE00}',
-    '\u{732A}',
-    '\u{FE01}',
-    '\u{7375}',
-    '\u{FE00}',
-    '\u{737A}',
-    '\u{FE00}',
-    '\u{7387}',
-    '\u{FE00}',
-    '\u{7387}',
-    '\u{FE01}',
-    '\u{738B}',
-    '\u{FE00}',
-    '\u{73A5}',
-    '\u{FE00}',
-    '\u{73B2}',
-    '\u{FE00}',
-    '\u{73DE}',
-    '\u{FE00}',
-    '\u{7406}',
-    '\u{FE00}',
-    '\u{7409}',
-    '\u{FE00}',
-    '\u{7422}',
-    '\u{FE00}',
-    '\u{7447}',
-    '\u{FE00}',
-    '\u{745C}',
-    '\u{FE00}',
-    '\u{7469}',
-    '\u{FE00}',
-    '\u{7471}',
-    '\u{FE00}',
-    '\u{7471}',
-    '\u{FE01}',
-    '\u{7485}',
-    '\u{FE00}',
-    '\u{7489}',
-    '\u{FE00}',
-    '\u{7498}',
-    '\u{FE00}',
-    '\u{74CA}',
-    '\u{FE00}',
-    '\u{7506}',
-    '\u{FE00}',
-    '\u{7524}',
-    '\u{FE00}',
-    '\u{753B}',
-    '\u{FE00}',
-    '\u{753E}',
-    '\u{FE00}',
-    '\u{7559}',
-    '\u{FE00}',
-    '\u{7565}',
-    '\u{FE00}',
-    '\u{7570}',
-    '\u{FE00}',
-    '\u{7570}',
-    '\u{FE01}',
-    '\u{75E2}',
-    '\u{FE00}',
-    '\u{7610}',
-    '\u{FE00}',
-    '\u{761D}',
-    '\u{FE00}',
-    '\u{761F}',
-    '\u{FE00}',
-    '\u{7642}',
-    '\u{FE00}',
-    '\u{7669}',
-    '\u{FE00}',
-    '\u{76CA}',
-    '\u{FE00}',
-    '\u{76CA}',
-    '\u{FE01}',
-    '\u{76DB}',
-    '\u{FE00}',
-    '\u{76E7}',
-    '\u{FE00}',
-    '\u{76F4}',
-    '\u{FE00}',
-    '\u{76F4}',
-    '\u{FE01}',
-    '\u{7701}',
-    '\u{FE00}',
-    '\u{771E}',
-    '\u{FE00}',
-    '\u{771F}',
-    '\u{FE00}',
-    '\u{771F}',
-    '\u{FE01}',
-    '\u{7740}',
-    '\u{FE00}',
-    '\u{774A}',
-    '\u{FE00}',
-    '\u{774A}',
-    '\u{FE01}',
-    '\u{778B}',
-    '\u{FE00}',
-    '\u{77A7}',
-    '\u{FE00}',
-    '\u{784E}',
-    '\u{FE00}',
-    '\u{786B}',
-    '\u{FE00}',
-    '\u{788C}',
-    '\u{FE00}',
-    '\u{788C}',
-    '\u{FE01}',
-    '\u{7891}',
-    '\u{FE00}',
-    '\u{78CA}',
-    '\u{FE00}',
-    '\u{78CC}',
-    '\u{FE00}',
-    '\u{78CC}',
-    '\u{FE01}',
-    '\u{78FB}',
-    '\u{FE00}',
-    '\u{792A}',
-    '\u{FE00}',
-    '\u{793C}',
-    '\u{FE00}',
-    '\u{793E}',
-    '\u{FE00}',
-    '\u{7948}',
-    '\u{FE00}',
-    '\u{7949}',
-    '\u{FE00}',
-    '\u{7950}',
-    '\u{FE00}',
-    '\u{7956}',
-    '\u{FE00}',
-    '\u{7956}',
-    '\u{FE01}',
-    '\u{795D}',
-    '\u{FE00}',
-    '\u{795E}',
-    '\u{FE00}',
-    '\u{7965}',
-    '\u{FE00}',
-    '\u{797F}',
-    '\u{FE00}',
-    '\u{798D}',
-    '\u{FE00}',
-    '\u{798E}',
-    '\u{FE00}',
-    '\u{798F}',
-    '\u{FE00}',
-    '\u{798F}',
-    '\u{FE01}',
-    '\u{79AE}',
-    '\u{FE00}',
-    '\u{79CA}',
-    '\u{FE00}',
-    '\u{79EB}',
-    '\u{FE00}',
-    '\u{7A1C}',
-    '\u{FE00}',
-    '\u{7A40}',
-    '\u{FE00}',
-    '\u{7A40}',
-    '\u{FE01}',
-    '\u{7A4A}',
-    '\u{FE00}',
-    '\u{7A4F}',
-    '\u{FE00}',
-    '\u{7A81}',
-    '\u{FE00}',
-    '\u{7AB1}',
-    '\u{FE00}',
-    '\u{7ACB}',
-    '\u{FE00}',
-    '\u{7AEE}',
-    '\u{FE00}',
-    '\u{7B20}',
-    '\u{FE00}',
-    '\u{7BC0}',
-    '\u{FE00}',
-    '\u{7BC0}',
-    '\u{FE01}',
-    '\u{7BC6}',
-    '\u{FE00}',
-    '\u{7BC9}',
-    '\u{FE00}',
-    '\u{7C3E}',
-    '\u{FE00}',
-    '\u{7C60}',
-    '\u{FE00}',
-    '\u{7C7B}',
-    '\u{FE00}',
-    '\u{7C92}',
-    '\u{FE00}',
-    '\u{7CBE}',
-    '\u{FE00}',
-    '\u{7CD2}',
-    '\u{FE00}',
-    '\u{7CD6}',
-    '\u{FE00}',
-    '\u{7CE3}',
-    '\u{FE00}',
-    '\u{7CE7}',
-    '\u{FE00}',
-    '\u{7CE8}',
-    '\u{FE00}',
-    '\u{7D00}',
-    '\u{FE00}',
-    '\u{7D10}',
-    '\u{FE00}',
-    '\u{7D22}',
-    '\u{FE00}',
-    '\u{7D2F}',
-    '\u{FE00}',
-    '\u{7D5B}',
-    '\u{FE00}',
-    '\u{7D63}',
-    '\u{FE00}',
-    '\u{7DA0}',
-    '\u{FE00}',
-    '\u{7DBE}',
-    '\u{FE00}',
-    '\u{7DC7}',
-    '\u{FE00}',
-    '\u{7DF4}',
-    '\u{FE00}',
-    '\u{7DF4}',
-    '\u{FE01}',
-    '\u{7DF4}',
-    '\u{FE02}',
-    '\u{7E02}',
-    '\u{FE00}',
-    '\u{7E09}',
-    '\u{FE00}',
-    '\u{7E37}',
-    '\u{FE00}',
-    '\u{7E41}',
-    '\u{FE00}',
-    '\u{7E45}',
-    '\u{FE00}',
-    '\u{7F3E}',
-    '\u{FE00}',
-    '\u{7F72}',
-    '\u{FE00}',
-    '\u{7F79}',
-    '\u{FE00}',
-    '\u{7F7A}',
-    '\u{FE00}',
-    '\u{7F85}',
-    '\u{FE00}',
-    '\u{7F95}',
-    '\u{FE00}',
-    '\u{7F9A}',
-    '\u{FE00}',
-    '\u{7FBD}',
-    '\u{FE00}',
-    '\u{7FFA}',
-    '\u{FE00}',
-    '\u{8001}',
-    '\u{FE00}',
-    '\u{8005}',
-    '\u{FE00}',
-    '\u{8005}',
-    '\u{FE01}',
-    '\u{8005}',
-    '\u{FE02}',
-    '\u{8046}',
-    '\u{FE00}',
-    '\u{8060}',
-    '\u{FE00}',
-    '\u{806F}',
-    '\u{FE00}',
-    '\u{8070}',
-    '\u{FE00}',
-    '\u{807E}',
-    '\u{FE00}',
-    '\u{808B}',
-    '\u{FE00}',
-    '\u{80AD}',
-    '\u{FE00}',
-    '\u{80B2}',
-    '\u{FE00}',
-    '\u{8103}',
-    '\u{FE00}',
-    '\u{813E}',
-    '\u{FE00}',
-    '\u{81D8}',
-    '\u{FE00}',
-    '\u{81E8}',
-    '\u{FE00}',
-    '\u{81ED}',
-    '\u{FE00}',
-    '\u{8201}',
-    '\u{FE00}',
-    '\u{8201}',
-    '\u{FE01}',
-    '\u{8204}',
-    '\u{FE00}',
-    '\u{8218}',
-    '\u{FE00}',
-    '\u{826F}',
-    '\u{FE00}',
-    '\u{8279}',
-    '\u{FE00}',
-    '\u{8279}',
-    '\u{FE01}',
-    '\u{828B}',
-    '\u{FE00}',
-    '\u{8291}',
-    '\u{FE00}',
-    '\u{829D}',
-    '\u{FE00}',
-    '\u{82B1}',
-    '\u{FE00}',
-    '\u{82B3}',
-    '\u{FE00}',
-    '\u{82BD}',
-    '\u{FE00}',
-    '\u{82E5}',
-    '\u{FE00}',
-    '\u{82E5}',
-    '\u{FE01}',
-    '\u{82E6}',
-    '\u{FE00}',
-    '\u{831D}',
-    '\u{FE00}',
-    '\u{8323}',
-    '\u{FE00}',
-    '\u{8336}',
-    '\u{FE00}',
-    '\u{8352}',
-    '\u{FE00}',
-    '\u{8353}',
-    '\u{FE00}',
-    '\u{8363}',
-    '\u{FE00}',
-    '\u{83AD}',
-    '\u{FE00}',
-    '\u{83BD}',
-    '\u{FE00}',
-    '\u{83C9}',
-    '\u{FE00}',
-    '\u{83CA}',
-    '\u{FE00}',
-    '\u{83CC}',
-    '\u{FE00}',
-    '\u{83DC}',
-    '\u{FE00}',
-    '\u{83E7}',
-    '\u{FE00}',
-    '\u{83EF}',
-    '\u{FE00}',
-    '\u{83F1}',
-    '\u{FE00}',
-    '\u{843D}',
-    '\u{FE00}',
-    '\u{8449}',
-    '\u{FE00}',
-    '\u{8457}',
-    '\u{FE00}',
-    '\u{8457}',
-    '\u{FE01}',
-    '\u{84EE}',
-    '\u{FE00}',
-    '\u{84F1}',
-    '\u{FE00}',
-    '\u{84F3}',
-    '\u{FE00}',
-    '\u{84FC}',
-    '\u{FE00}',
-    '\u{8516}',
-    '\u{FE00}',
-    '\u{8564}',
-    '\u{FE00}',
-    '\u{85CD}',
-    '\u{FE00}',
-    '\u{85FA}',
-    '\u{FE00}',
-    '\u{8606}',
-    '\u{FE00}',
-    '\u{8612}',
-    '\u{FE00}',
-    '\u{862D}',
-    '\u{FE00}',
-    '\u{863F}',
-    '\u{FE00}',
-    '\u{8650}',
-    '\u{FE00}',
-    '\u{865C}',
-    '\u{FE00}',
-    '\u{865C}',
-    '\u{FE01}',
-    '\u{8667}',
-    '\u{FE00}',
-    '\u{8669}',
-    '\u{FE00}',
-    '\u{8688}',
-    '\u{FE00}',
-    '\u{86A9}',
-    '\u{FE00}',
-    '\u{86E2}',
-    '\u{FE00}',
-    '\u{870E}',
-    '\u{FE00}',
-    '\u{8728}',
-    '\u{FE00}',
-    '\u{876B}',
-    '\u{FE00}',
-    '\u{8779}',
-    '\u{FE00}',
-    '\u{8779}',
-    '\u{FE01}',
-    '\u{8786}',
-    '\u{FE00}',
-    '\u{87BA}',
-    '\u{FE00}',
-    '\u{87E1}',
-    '\u{FE00}',
-    '\u{8801}',
-    '\u{FE00}',
-    '\u{881F}',
-    '\u{FE00}',
-    '\u{884C}',
-    '\u{FE00}',
-    '\u{8860}',
-    '\u{FE00}',
-    '\u{8863}',
-    '\u{FE00}',
-    '\u{88C2}',
-    '\u{FE00}',
-    '\u{88CF}',
-    '\u{FE00}',
-    '\u{88D7}',
-    '\u{FE00}',
-    '\u{88DE}',
-    '\u{FE00}',
-    '\u{88E1}',
-    '\u{FE00}',
-    '\u{88F8}',
-    '\u{FE00}',
-    '\u{88FA}',
-    '\u{FE00}',
-    '\u{8910}',
-    '\u{FE00}',
-    '\u{8941}',
-    '\u{FE00}',
-    '\u{8964}',
-    '\u{FE00}',
-    '\u{8986}',
-    '\u{FE00}',
-    '\u{898B}',
-    '\u{FE00}',
-    '\u{8996}',
-    '\u{FE00}',
-    '\u{8996}',
-    '\u{FE01}',
-    '\u{8AA0}',
-    '\u{FE00}',
-    '\u{8AAA}',
-    '\u{FE00}',
-    '\u{8AAA}',
-    '\u{FE01}',
-    '\u{8ABF}',
-    '\u{FE00}',
-    '\u{8ACB}',
-    '\u{FE00}',
-    '\u{8AD2}',
-    '\u{FE00}',
-    '\u{8AD6}',
-    '\u{FE00}',
-    '\u{8AED}',
-    '\u{FE00}',
-    '\u{8AED}',
-    '\u{FE01}',
-    '\u{8AF8}',
-    '\u{FE00}',
-    '\u{8AF8}',
-    '\u{FE01}',
-    '\u{8AFE}',
-    '\u{FE00}',
-    '\u{8AFE}',
-    '\u{FE01}',
-    '\u{8B01}',
-    '\u{FE00}',
-    '\u{8B01}',
-    '\u{FE01}',
-    '\u{8B39}',
-    '\u{FE00}',
-    '\u{8B39}',
-    '\u{FE01}',
-    '\u{8B58}',
-    '\u{FE00}',
-    '\u{8B80}',
-    '\u{FE00}',
-    '\u{8B8A}',
-    '\u{FE00}',
-    '\u{8B8A}',
-    '\u{FE01}',
-    '\u{8C48}',
-    '\u{FE00}',
-    '\u{8C55}',
-    '\u{FE00}',
-    '\u{8CAB}',
-    '\u{FE00}',
-    '\u{8CC1}',
-    '\u{FE00}',
-    '\u{8CC2}',
-    '\u{FE00}',
-    '\u{8CC8}',
-    '\u{FE00}',
-    '\u{8CD3}',
-    '\u{FE00}',
-    '\u{8D08}',
-    '\u{FE00}',
-    '\u{8D08}',
-    '\u{FE01}',
-    '\u{8D1B}',
-    '\u{FE00}',
-    '\u{8D77}',
-    '\u{FE00}',
-    '\u{8DBC}',
-    '\u{FE00}',
-    '\u{8DCB}',
-    '\u{FE00}',
-    '\u{8DEF}',
-    '\u{FE00}',
-    '\u{8DF0}',
-    '\u{FE00}',
-    '\u{8ECA}',
-    '\u{FE00}',
-    '\u{8ED4}',
-    '\u{FE00}',
-    '\u{8F26}',
-    '\u{FE00}',
-    '\u{8F2A}',
-    '\u{FE00}',
-    '\u{8F38}',
-    '\u{FE00}',
-    '\u{8F38}',
-    '\u{FE01}',
-    '\u{8F3B}',
-    '\u{FE00}',
-    '\u{8F62}',
-    '\u{FE00}',
-    '\u{8F9E}',
-    '\u{FE00}',
-    '\u{8FB0}',
-    '\u{FE00}',
-    '\u{8FB6}',
-    '\u{FE00}',
-    '\u{9023}',
-    '\u{FE00}',
-    '\u{9038}',
-    '\u{FE00}',
-    '\u{9038}',
-    '\u{FE01}',
-    '\u{9072}',
-    '\u{FE00}',
-    '\u{907C}',
-    '\u{FE00}',
-    '\u{908F}',
-    '\u{FE00}',
-    '\u{9094}',
-    '\u{FE00}',
-    '\u{90CE}',
-    '\u{FE00}',
-    '\u{90DE}',
-    '\u{FE00}',
-    '\u{90F1}',
-    '\u{FE00}',
-    '\u{90FD}',
-    '\u{FE00}',
-    '\u{9111}',
-    '\u{FE00}',
-    '\u{911B}',
-    '\u{FE00}',
-    '\u{916A}',
-    '\u{FE00}',
-    '\u{9199}',
-    '\u{FE00}',
-    '\u{91B4}',
-    '\u{FE00}',
-    '\u{91CC}',
-    '\u{FE00}',
-    '\u{91CF}',
-    '\u{FE00}',
-    '\u{91D1}',
-    '\u{FE00}',
-    '\u{9234}',
-    '\u{FE00}',
-    '\u{9238}',
-    '\u{FE00}',
-    '\u{9276}',
-    '\u{FE00}',
-    '\u{927C}',
-    '\u{FE00}',
-    '\u{92D7}',
-    '\u{FE00}',
-    '\u{92D8}',
-    '\u{FE00}',
-    '\u{9304}',
-    '\u{FE00}',
-    '\u{934A}',
-    '\u{FE00}',
-    '\u{93F9}',
-    '\u{FE00}',
-    '\u{9415}',
-    '\u{FE00}',
-    '\u{958B}',
-    '\u{FE00}',
-    '\u{95AD}',
-    '\u{FE00}',
-    '\u{95B7}',
-    '\u{FE00}',
-    '\u{962E}',
-    '\u{FE00}',
-    '\u{964B}',
-    '\u{FE00}',
-    '\u{964D}',
-    '\u{FE00}',
-    '\u{9675}',
-    '\u{FE00}',
-    '\u{9678}',
-    '\u{FE00}',
-    '\u{967C}',
-    '\u{FE00}',
-    '\u{9686}',
-    '\u{FE00}',
-    '\u{96A3}',
-    '\u{FE00}',
-    '\u{96B7}',
-    '\u{FE00}',
-    '\u{96B8}',
-    '\u{FE00}',
-    '\u{96C3}',
-    '\u{FE00}',
-    '\u{96E2}',
-    '\u{FE00}',
-    '\u{96E3}',
-    '\u{FE00}',
-    '\u{96E3}',
-    '\u{FE01}',
-    '\u{96F6}',
-    '\u{FE00}',
-    '\u{96F7}',
-    '\u{FE00}',
-    '\u{9723}',
-    '\u{FE00}',
-    '\u{9732}',
-    '\u{FE00}',
-    '\u{9748}',
-    '\u{FE00}',
-    '\u{9756}',
-    '\u{FE00}',
-    '\u{9756}',
-    '\u{FE01}',
-    '\u{97DB}',
-    '\u{FE00}',
-    '\u{97E0}',
-    '\u{FE00}',
-    '\u{97FF}',
-    '\u{FE00}',
-    '\u{97FF}',
-    '\u{FE01}',
-    '\u{980B}',
-    '\u{FE00}',
-    '\u{980B}',
-    '\u{FE01}',
-    '\u{980B}',
-    '\u{FE02}',
-    '\u{9818}',
-    '\u{FE00}',
-    '\u{9829}',
-    '\u{FE00}',
-    '\u{983B}',
-    '\u{FE00}',
-    '\u{983B}',
-    '\u{FE01}',
-    '\u{985E}',
-    '\u{FE00}',
-    '\u{98E2}',
-    '\u{FE00}',
-    '\u{98EF}',
-    '\u{FE00}',
-    '\u{98FC}',
-    '\u{FE00}',
-    '\u{9928}',
-    '\u{FE00}',
-    '\u{9929}',
-    '\u{FE00}',
-    '\u{99A7}',
-    '\u{FE00}',
-    '\u{99C2}',
-    '\u{FE00}',
-    '\u{99F1}',
-    '\u{FE00}',
-    '\u{99FE}',
-    '\u{FE00}',
-    '\u{9A6A}',
-    '\u{FE00}',
-    '\u{9B12}',
-    '\u{FE00}',
-    '\u{9B12}',
-    '\u{FE01}',
-    '\u{9B6F}',
-    '\u{FE00}',
-    '\u{9C40}',
-    '\u{FE00}',
-    '\u{9C57}',
-    '\u{FE00}',
-    '\u{9CFD}',
-    '\u{FE00}',
-    '\u{9D67}',
-    '\u{FE00}',
-    '\u{9DB4}',
-    '\u{FE00}',
-    '\u{9DFA}',
-    '\u{FE00}',
-    '\u{9E1E}',
-    '\u{FE00}',
-    '\u{9E7F}',
-    '\u{FE00}',
-    '\u{9E97}',
-    '\u{FE00}',
-    '\u{9E9F}',
-    '\u{FE00}',
-    '\u{9EBB}',
-    '\u{FE00}',
-    '\u{9ECE}',
-    '\u{FE00}',
-    '\u{9EF9}',
-    '\u{FE00}',
-    '\u{9EFE}',
-    '\u{FE00}',
-    '\u{9F05}',
-    '\u{FE00}',
-    '\u{9F0F}',
-    '\u{FE00}',
-    '\u{9F16}',
-    '\u{FE00}',
-    '\u{9F3B}',
-    '\u{FE00}',
-    '\u{9F43}',
-    '\u{FE00}',
-    '\u{9F8D}',
-    '\u{FE00}',
-    '\u{9F8E}',
-    '\u{FE00}',
-    '\u{9F9C}',
-    '\u{FE00}',
-    '\u{9F9C}',
-    '\u{FE01}',
-    '\u{9F9C}',
-    '\u{FE02}',
-    '\u{20122}',
-    '\u{FE00}',
-    '\u{2051C}',
-    '\u{FE00}',
-    '\u{20525}',
-    '\u{FE00}',
-    '\u{2054B}',
-    '\u{FE00}',
-    '\u{2063A}',
-    '\u{FE00}',
-    '\u{20804}',
-    '\u{FE00}',
-    '\u{208DE}',
-    '\u{FE00}',
-    '\u{20A2C}',
-    '\u{FE00}',
-    '\u{20B63}',
-    '\u{FE00}',
-    '\u{214E4}',
-    '\u{FE00}',
-    '\u{216A8}',
-    '\u{FE00}',
-    '\u{216EA}',
-    '\u{FE00}',
-    '\u{219C8}',
-    '\u{FE00}',
-    '\u{21B18}',
-    '\u{FE00}',
-    '\u{21D0B}',
-    '\u{FE00}',
-    '\u{21DE4}',
-    '\u{FE00}',
-    '\u{21DE6}',
-    '\u{FE00}',
-    '\u{22183}',
-    '\u{FE00}',
-    '\u{2219F}',
-    '\u{FE00}',
-    '\u{22331}',
-    '\u{FE00}',
-    '\u{22331}',
-    '\u{FE01}',
-    '\u{226D4}',
-    '\u{FE00}',
-    '\u{22844}',
-    '\u{FE00}',
-    '\u{2284A}',
-    '\u{FE00}',
-    '\u{22B0C}',
-    '\u{FE00}',
-    '\u{22BF1}',
-    '\u{FE00}',
-    '\u{2300A}',
-    '\u{FE00}',
-    '\u{232B8}',
-    '\u{FE00}',
-    '\u{2335F}',
-    '\u{FE00}',
-    '\u{23393}',
-    '\u{FE00}',
-    '\u{2339C}',
-    '\u{FE00}',
-    '\u{233C3}',
-    '\u{FE00}',
-    '\u{233D5}',
-    '\u{FE00}',
-    '\u{2346D}',
-    '\u{FE00}',
-    '\u{236A3}',
-    '\u{FE00}',
-    '\u{238A7}',
-    '\u{FE00}',
-    '\u{23A8D}',
-    '\u{FE00}',
-    '\u{23AFA}',
-    '\u{FE00}',
-    '\u{23CBC}',
-    '\u{FE00}',
-    '\u{23D1E}',
-    '\u{FE00}',
-    '\u{23ED1}',
-    '\u{FE00}',
-    '\u{23F5E}',
-    '\u{FE00}',
-    '\u{23F8E}',
-    '\u{FE00}',
-    '\u{24263}',
-    '\u{FE00}',
-    '\u{242EE}',
-    '\u{FE00}',
-    '\u{243AB}',
-    '\u{FE00}',
-    '\u{24608}',
-    '\u{FE00}',
-    '\u{24735}',
-    '\u{FE00}',
-    '\u{24814}',
-    '\u{FE00}',
-    '\u{24C36}',
-    '\u{FE00}',
-    '\u{24C92}',
-    '\u{FE00}',
-    '\u{24FA1}',
-    '\u{FE00}',
-    '\u{24FB8}',
-    '\u{FE00}',
-    '\u{25044}',
-    '\u{FE00}',
-    '\u{250F2}',
-    '\u{FE00}',
-    '\u{250F3}',
-    '\u{FE00}',
-    '\u{25119}',
-    '\u{FE00}',
-    '\u{25133}',
-    '\u{FE00}',
-    '\u{25249}',
-    '\u{FE00}',
-    '\u{2541D}',
-    '\u{FE00}',
-    '\u{25626}',
-    '\u{FE00}',
-    '\u{2569A}',
-    '\u{FE00}',
-    '\u{256C5}',
-    '\u{FE00}',
-    '\u{2597C}',
-    '\u{FE00}',
-    '\u{25AA7}',
-    '\u{FE00}',
-    '\u{25AA7}',
-    '\u{FE01}',
-    '\u{25BAB}',
-    '\u{FE00}',
-    '\u{25C80}',
-    '\u{FE00}',
-    '\u{25CD0}',
-    '\u{FE00}',
-    '\u{25F86}',
-    '\u{FE00}',
-    '\u{261DA}',
-    '\u{FE00}',
-    '\u{26228}',
-    '\u{FE00}',
-    '\u{26247}',
-    '\u{FE00}',
-    '\u{262D9}',
-    '\u{FE00}',
-    '\u{2633E}',
-    '\u{FE00}',
-    '\u{264DA}',
-    '\u{FE00}',
-    '\u{26523}',
-    '\u{FE00}',
-    '\u{265A8}',
-    '\u{FE00}',
-    '\u{267A7}',
-    '\u{FE00}',
-    '\u{267B5}',
-    '\u{FE00}',
-    '\u{26B3C}',
-    '\u{FE00}',
-    '\u{26C36}',
-    '\u{FE00}',
-    '\u{26CD5}',
-    '\u{FE00}',
-    '\u{26D6B}',
-    '\u{FE00}',
-    '\u{26F2C}',
-    '\u{FE00}',
-    '\u{26FB1}',
-    '\u{FE00}',
-    '\u{270D2}',
-    '\u{FE00}',
-    '\u{273CA}',
-    '\u{FE00}',
-    '\u{27667}',
-    '\u{FE00}',
-    '\u{278AE}',
-    '\u{FE00}',
-    '\u{27966}',
-    '\u{FE00}',
-    '\u{27CA8}',
-    '\u{FE00}',
-    '\u{27ED3}',
-    '\u{FE00}',
-    '\u{27F2F}',
-    '\u{FE00}',
-    '\u{285D2}',
-    '\u{FE00}',
-    '\u{285ED}',
-    '\u{FE00}',
-    '\u{2872E}',
-    '\u{FE00}',
-    '\u{28BFA}',
-    '\u{FE00}',
-    '\u{28D77}',
-    '\u{FE00}',
-    '\u{29145}',
-    '\u{FE00}',
-    '\u{291DF}',
-    '\u{FE00}',
-    '\u{2921A}',
-    '\u{FE00}',
-    '\u{2940A}',
-    '\u{FE00}',
-    '\u{29496}',
-    '\u{FE00}',
-    '\u{295B6}',
-    '\u{FE00}',
-    '\u{29B30}',
-    '\u{FE00}',
-    '\u{2A0CE}',
-    '\u{FE00}',
-    '\u{2A105}',
-    '\u{FE00}',
-    '\u{2A20E}',
-    '\u{FE00}',
-    '\u{2A291}',
-    '\u{FE00}',
-    '\u{2A392}',
-    '\u{FE00}',
-    '\u{2A600}',
-    '\u{FE00}',
-];
-
-pub(crate) const CJK_COMPAT_VARIANTS_DECOMPOSED_SALT: &[u16] = &[
-    0x005, 0x000, 0x000, 0x000, 0x162, 0x014, 0x0B6, 0x000, 0x183, 0x00D, 0x000, 0x000, 0x035,
-    0x011, 0x007, 0x000, 0x01C, 0x000, 0x001, 0x000, 0x0D3, 0x00B, 0x00A, 0x0E1, 0x000, 0x000,
-    0x000, 0x048, 0x072, 0x0C7, 0x002, 0x021, 0x015, 0x02C, 0x000, 0x000, 0x000, 0x005, 0x01F,
-    0x008, 0x007, 0x000, 0x004, 0x000, 0x007, 0x010, 0x000, 0x000, 0x000, 0x04E, 0x000, 0x006,
-    0x000, 0x011, 0x014, 0x004, 0x01A, 0x002, 0x058, 0x000, 0x017, 0x000, 0x000, 0x000, 0x004,
-    0x000, 0x001, 0x000, 0x001, 0x000, 0x004, 0x006, 0x016, 0x020, 0x004, 0x000, 0x01E, 0x030,
-    0x000, 0x024, 0x01A, 0x017, 0x000, 0x0A0, 0x029, 0x034, 0x002, 0x000, 0x004, 0x000, 0x023,
-    0x029, 0x021, 0x000, 0x000, 0x00B, 0x000, 0x020, 0x001, 0x007, 0x008, 0x009, 0x008, 0x000,
-    0x001, 0x000, 0x001, 0x004, 0x003, 0x01D, 0x000, 0x000, 0x000, 0x001, 0x029, 0x00D, 0x007,
-    0x000, 0x000, 0x002, 0x00E, 0x009, 0x004, 0x00C, 0x001, 0x013, 0x005, 0x006, 0x005, 0x001,
-    0x009, 0x001, 0x00A, 0x002, 0x000, 0x008, 0x029, 0x000, 0x008, 0x002, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x00D, 0x000, 0x009, 0x010, 0x00F, 0x000, 0x011, 0x00F, 0x000,
-    0x008, 0x001, 0x001, 0x005, 0x000, 0x001, 0x026, 0x005, 0x039, 0x008, 0x001, 0x017, 0x00D,
-    0x004, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x00E, 0x000, 0x005, 0x000,
-    0x000, 0x000, 0x000, 0x004, 0x000, 0x001, 0x002, 0x004, 0x003, 0x035, 0x001, 0x002, 0x001,
-    0x007, 0x000, 0x000, 0x003, 0x002, 0x011, 0x000, 0x00D, 0x003, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x004, 0x005, 0x000, 0x00E, 0x000, 0x000, 0x003, 0x006, 0x002,
-    0x00B, 0x002, 0x001, 0x003, 0x012, 0x00B, 0x000, 0x000, 0x000, 0x002, 0x00B, 0x001, 0x004,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x02F, 0x001,
-    0x013, 0x00B, 0x004, 0x002, 0x004, 0x004, 0x000, 0x00B, 0x004, 0x000, 0x00B, 0x004, 0x00D,
-    0x00C, 0x000, 0x01E, 0x000, 0x021, 0x00D, 0x002, 0x007, 0x000, 0x000, 0x000, 0x001, 0x002,
-    0x000, 0x020, 0x000, 0x000, 0x000, 0x000, 0x000, 0x01F, 0x001, 0x002, 0x000, 0x000, 0x005,
-    0x000, 0x000, 0x004, 0x000, 0x011, 0x002, 0x008, 0x007, 0x000, 0x000, 0x00C, 0x003, 0x000,
-    0x004, 0x00E, 0x023, 0x004, 0x001, 0x000, 0x002, 0x000, 0x004, 0x008, 0x010, 0x002, 0x000,
-    0x013, 0x00D, 0x000, 0x00B, 0x009, 0x006, 0x000, 0x000, 0x009, 0x00C, 0x00A, 0x004, 0x01A,
-    0x003, 0x001, 0x003, 0x000, 0x001, 0x000, 0x006, 0x003, 0x00A, 0x000, 0x00A, 0x006, 0x008,
-    0x008, 0x003, 0x019, 0x000, 0x000, 0x000, 0x000, 0x00C, 0x005, 0x000, 0x005, 0x001, 0x000,
-    0x002, 0x000, 0x008, 0x000, 0x00C, 0x000, 0x002, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000,
-    0x004, 0x002, 0x015, 0x000, 0x004, 0x001, 0x012, 0x004, 0x003, 0x00C, 0x004, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x003, 0x000, 0x005, 0x002, 0x000, 0x001, 0x002, 0x001,
-    0x010, 0x004, 0x000, 0x005, 0x002, 0x001, 0x006, 0x000, 0x000, 0x000, 0x000, 0x00A, 0x008,
-    0x002, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x004, 0x004, 0x00C, 0x002,
-    0x000, 0x006, 0x003, 0x003, 0x00F, 0x000, 0x003, 0x005, 0x001, 0x000, 0x000, 0x008, 0x000,
-    0x002, 0x004, 0x002, 0x013, 0x000, 0x000, 0x000, 0x00A, 0x006, 0x001, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x00A, 0x000, 0x005, 0x000, 0x005, 0x000, 0x006, 0x000, 0x001,
-    0x001, 0x005, 0x001, 0x00A, 0x009, 0x005, 0x001, 0x000, 0x007, 0x001, 0x001, 0x007, 0x001,
-    0x01F, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002,
-    0x011, 0x005, 0x003, 0x005, 0x003, 0x001, 0x001, 0x000, 0x004, 0x001, 0x004, 0x001, 0x008,
-    0x000, 0x019, 0x000, 0x004, 0x003, 0x005, 0x006, 0x000, 0x011, 0x00E, 0x005, 0x001, 0x000,
-    0x01A, 0x004, 0x000, 0x003, 0x000, 0x000, 0x005, 0x000, 0x000, 0x001, 0x017, 0x000, 0x006,
-    0x003, 0x00F, 0x001, 0x006, 0x009, 0x000, 0x005, 0x000, 0x003, 0x001, 0x017, 0x007, 0x000,
-    0x002, 0x005, 0x003, 0x002, 0x000, 0x007, 0x001, 0x000, 0x004, 0x000, 0x000, 0x005, 0x015,
-    0x004, 0x000, 0x003, 0x001, 0x003, 0x007, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000,
-    0x009, 0x000, 0x000, 0x000, 0x000, 0x000, 0x009, 0x000, 0x000, 0x000, 0x001, 0x003, 0x000,
-    0x000, 0x003, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x003, 0x008, 0x000,
-    0x002, 0x002, 0x003, 0x005, 0x000, 0x000, 0x000, 0x008, 0x003, 0x002, 0x000, 0x009, 0x004,
-    0x000, 0x006, 0x00F, 0x001, 0x000, 0x000, 0x004, 0x002, 0x002, 0x004, 0x004, 0x00D, 0x000,
-    0x000, 0x000, 0x001, 0x000, 0x002, 0x005, 0x000, 0x000, 0x00C, 0x004, 0x009, 0x002, 0x008,
-    0x001, 0x000, 0x005, 0x004, 0x001, 0x002, 0x001, 0x005, 0x002, 0x00B, 0x004, 0x00D, 0x004,
-    0x000, 0x001, 0x018, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x003,
-    0x000, 0x002, 0x00A, 0x002, 0x004, 0x004, 0x000, 0x000, 0x000, 0x001, 0x000, 0x00C, 0x001,
-    0x00C, 0x001, 0x009, 0x00B, 0x000, 0x001, 0x000, 0x002, 0x000, 0x005, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x007, 0x002, 0x000, 0x006, 0x004, 0x00A, 0x001, 0x001,
-    0x005, 0x002, 0x006, 0x004, 0x003, 0x00D, 0x002, 0x002, 0x000, 0x001, 0x002, 0x003, 0x002,
-    0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002, 0x000, 0x001,
-    0x000, 0x000, 0x003, 0x002, 0x000, 0x005, 0x002, 0x005, 0x002, 0x001, 0x004, 0x001, 0x001,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x007, 0x002, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x002, 0x000, 0x000, 0x004, 0x008, 0x000,
-    0x003, 0x002, 0x002, 0x002, 0x002, 0x004, 0x001, 0x004, 0x002, 0x000, 0x001, 0x004, 0x001,
-    0x001, 0x002, 0x000, 0x000, 0x00C, 0x000, 0x001, 0x002, 0x000, 0x006, 0x002, 0x000, 0x000,
-    0x008, 0x001, 0x009, 0x001, 0x003, 0x000, 0x004, 0x001, 0x000, 0x006, 0x000, 0x003, 0x007,
-    0x000, 0x000, 0x002, 0x001, 0x000, 0x003, 0x002, 0x000, 0x002, 0x007, 0x000, 0x000, 0x000,
-    0x000, 0x005, 0x003, 0x001, 0x003, 0x000, 0x005, 0x000, 0x001, 0x000, 0x003, 0x001, 0x001,
-    0x002, 0x003, 0x000, 0x002, 0x003, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x001,
-    0x000, 0x004, 0x003, 0x002, 0x004, 0x003, 0x005, 0x002, 0x000, 0x000, 0x001, 0x003, 0x002,
-    0x000, 0x000, 0x004, 0x003, 0x000, 0x001, 0x006, 0x001, 0x004, 0x000, 0x002, 0x002, 0x001,
-    0x000, 0x00D, 0x001, 0x000, 0x000, 0x001, 0x000, 0x002, 0x003, 0x008, 0x005, 0x007, 0x006,
-    0x000, 0x001, 0x006, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x002, 0x000, 0x001, 0x000, 0x000, 0x001, 0x001, 0x002, 0x004, 0x002, 0x001, 0x001,
-    0x002, 0x000, 0x000, 0x000, 0x001, 0x005, 0x001, 0x000, 0x002, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x004, 0x000, 0x002, 0x000, 0x001, 0x003,
-    0x003, 0x001, 0x000, 0x004, 0x000, 0x001, 0x001, 0x001, 0x001, 0x001, 0x004, 0x000, 0x000,
-    0x003, 0x001, 0x003, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x002,
-    0x000, 0x000, 0x001, 0x003, 0x002, 0x001, 0x002, 0x001, 0x009, 0x001, 0x000, 0x001, 0x003,
-    0x004, 0x000, 0x000, 0x000, 0x002, 0x000, 0x003, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002, 0x001, 0x004, 0x001, 0x001, 0x001, 0x002,
-    0x001, 0x006, 0x001, 0x001, 0x002, 0x001, 0x000, 0x000, 0x000, 0x003, 0x001, 0x000, 0x005,
-    0x001,
-];
-pub(crate) const CJK_COMPAT_VARIANTS_DECOMPOSED_KV: &[(u32, (u16, u16))] = &[
-    (0x0FA08, (0x5A8, 0x2)),
-    (0x2F825, (0x118, 0x2)),
-    (0x2F838, (0x704, 0x2)),
-    (0x2F95B, (0x4A8, 0x2)),
-    (0x2F8FB, (0x740, 0x2)),
-    (0x2F83A, (0x154, 0x2)),
-    (0x2F8A7, (0x27C, 0x2)),
-    (0x2F856, (0x1A6, 0x2)),
-    (0x2F810, (0x0D0, 0x2)),
-    (0x0FA8B, (0x29C, 0x2)),
-    (0x0FA7A, (0x17A, 0x2)),
-    (0x2F9EF, (0x076, 0x2)),
-    (0x2F959, (0x4A4, 0x2)),
-    (0x0F9C8, (0x324, 0x2)),
-    (0x0F9C4, (0x6EA, 0x2)),
-    (0x2F833, (0x148, 0x2)),
-    (0x0F96C, (0x1AE, 0x2)),
-    (0x0F9A1, (0x5CE, 0x2)),
-    (0x0F906, (0x150, 0x2)),
-    (0x2FA01, (0x7C4, 0x2)),
-    (0x0F94C, (0x34C, 0x2)),
-    (0x0F90F, (0x4FA, 0x2)),
-    (0x2F8DD, (0x732, 0x2)),
-    (0x0FA55, (0x4AA, 0x2)),
-    (0x2F860, (0x708, 0x2)),
-    (0x2F999, (0x546, 0x2)),
-    (0x0FABC, (0x5E6, 0x2)),
-    (0x2F9B9, (0x594, 0x2)),
-    (0x0F943, (0x246, 0x2)),
-    (0x2F952, (0x76C, 0x2)),
-    (0x2F8F1, (0x358, 0x2)),
-    (0x0F99C, (0x100, 0x2)),
-    (0x0F969, (0x2EC, 0x2)),
-    (0x0F98D, (0x620, 0x2)),
-    (0x0FA7F, (0x1CC, 0x2)),
-    (0x2F9D6, (0x606, 0x2)),
-    (0x2F81B, (0x0EC, 0x2)),
-    (0x0FA9D, (0x466, 0x2)),
-    (0x2F8E4, (0x33A, 0x2)),
-    (0x0FA94, (0x320, 0x2)),
-    (0x2F890, (0x244, 0x2)),
-    (0x0F93D, (0x4DC, 0x2)),
-    (0x2F924, (0x3F8, 0x2)),
-    (0x2F983, (0x51C, 0x2)),
-    (0x0FA2F, (0x678, 0x2)),
-    (0x2F891, (0x71A, 0x2)),
-    (0x2F934, (0x430, 0x2)),
-    (0x2F835, (0x3CC, 0x2)),
-    (0x2F899, (0x24E, 0x2)),
-    (0x2F8AE, (0x294, 0x2)),
-    (0x0F9D6, (0x39A, 0x2)),
-    (0x2F9A0, (0x54E, 0x2)),
-    (0x0FAC2, (0x61A, 0x2)),
-    (0x2F851, (0x1BA, 0x2)),
-    (0x2F804, (0x0A6, 0x2)),
-    (0x2F90D, (0x744, 0x2)),
-    (0x0F95E, (0x094, 0x2)),
-    (0x2F8DA, (0x31A, 0x2)),
-    (0x2F885, (0x226, 0x2)),
-    (0x2F96A, (0x4D0, 0x2)),
-    (0x0F907, (0x6EE, 0x2)),
-    (0x0F9F9, (0x4C2, 0x2)),
-    (0x0F94B, (0x202, 0x2)),
-    (0x2F915, (0x3C2, 0x2)),
-    (0x0F9F1, (0x676, 0x2)),
-    (0x2F86D, (0x1EA, 0x2)),
-    (0x2F921, (0x3F2, 0x2)),
-    (0x0FA96, (0x366, 0x2)),
-    (0x0F9E0, (0x2F6, 0x2)),
-    (0x0F921, (0x214, 0x2)),
-    (0x2F99F, (0x56A, 0x2)),
-    (0x2F8B2, (0x2A6, 0x2)),
-    (0x0FAB1, (0x4F2, 0x2)),
-    (0x0FA6C, (0x74C, 0x2)),
-    (0x2F819, (0x0A2, 0x2)),
-    (0x2F910, (0x746, 0x2)),
-    (0x2F8DC, (0x31E, 0x2)),
-    (0x2F9D3, (0x7AA, 0x2)),
-    (0x2F8A3, (0x26E, 0x2)),
-    (0x0F915, (0x37C, 0x2)),
-    (0x2F88A, (0x014, 0x2)),
-    (0x0F9F6, (0x522, 0x2)),
-    (0x2F9F1, (0x7B8, 0x2)),
-    (0x0F98E, (0x22C, 0x2)),
-    (0x0FAD5, (0x768, 0x2)),
-    (0x0F93B, (0x46C, 0x2)),
-    (0x2F91E, (0x3E2, 0x2)),
-    (0x0F9EB, (0x134, 0x2)),
-    (0x0FA42, (0x2F2, 0x2)),
-    (0x2F958, (0x04E, 0x2)),
-    (0x0FA19, (0x48C, 0x2)),
-    (0x0FAAA, (0x45E, 0x2)),
-    (0x2F949, (0x046, 0x2)),
-    (0x2F978, (0x4FC, 0x2)),
-    (0x2F8A9, (0x27E, 0x2)),
-    (0x2F90A, (0x032, 0x2)),
-    (0x2F89A, (0x252, 0x2)),
-    (0x2F8B5, (0x2B0, 0x2)),
-    (0x2F94C, (0x04A, 0x2)),
-    (0x0FA43, (0x300, 0x2)),
-    (0x0F997, (0x510, 0x2)),
-    (0x2F8BA, (0x2BA, 0x2)),
-    (0x0FA00, (0x0FC, 0x2)),
-    (0x0FAC3, (0x62E, 0x2)),
-    (0x2F948, (0x462, 0x2)),
-    (0x2F9F4, (0x21C, 0x2)),
-    (0x0FA99, (0x3AA, 0x2)),
-    (0x2F976, (0x4F8, 0x2)),
-    (0x0F978, (0x0D6, 0x2)),
-    (0x2F8FE, (0x36E, 0x2)),
-    (0x2F8E3, (0x736, 0x2)),
-    (0x0F919, (0x642, 0x2)),
-    (0x2F8EF, (0x356, 0x2)),
-    (0x0F939, (0x6C2, 0x2)),
-    (0x2F8C9, (0x2EA, 0x2)),
-    (0x2F844, (0x172, 0x2)),
-    (0x0FABB, (0x5D2, 0x2)),
-    (0x2F9C4, (0x5AC, 0x2)),
-    (0x2F984, (0x060, 0x2)),
-    (0x2F802, (0x098, 0x2)),
-    (0x0FA15, (0x0F6, 0x2)),
-    (0x0F9BE, (0x2EE, 0x2)),
-    (0x0F942, (0x1B8, 0x2)),
-    (0x2F852, (0x19E, 0x2)),
-    (0x0FAAE, (0x4C0, 0x2)),
-    (0x2FA17, (0x6DC, 0x2)),
-    (0x2F92D, (0x03A, 0x2)),
-    (0x2F83F, (0x162, 0x2)),
-    (0x0F90C, (0x1C8, 0x2)),
-    (0x0F931, (0x350, 0x2)),
-    (0x0F9C1, (0x446, 0x2)),
-    (0x2F873, (0x1FA, 0x2)),
-    (0x2F965, (0x77A, 0x2)),
-    (0x0F902, (0x612, 0x2)),
-    (0x2F805, (0x0B0, 0x2)),
-    (0x2F8CA, (0x728, 0x2)),
-    (0x0F9C7, (0x10E, 0x2)),
-    (0x2F8F4, (0x360, 0x2)),
-    (0x0FA0D, (0x186, 0x2)),
-    (0x0FA5C, (0x524, 0x2)),
-    (0x0FA4C, (0x47E, 0x2)),
-    (0x2F865, (0x1D2, 0x2)),
-    (0x2F876, (0x00E, 0x2)),
-    (0x2F9D7, (0x608, 0x2)),
-    (0x0F975, (0x2C8, 0x2)),
-    (0x2F9BB, (0x59C, 0x2)),
-    (0x2F9D2, (0x5F6, 0x2)),
-    (0x0F9ED, (0x15A, 0x2)),
-    (0x2F9B4, (0x588, 0x2)),
-    (0x0FA6D, (0x52C, 0x2)),
-    (0x0F9E5, (0x43E, 0x2)),
-    (0x2F8D8, (0x314, 0x2)),
-    (0x2F93D, (0x75E, 0x2)),
-    (0x0FA03, (0x4C8, 0x2)),
-    (0x0F9A0, (0x5AE, 0x2)),
-    (0x2FA12, (0x7CA, 0x2)),
-    (0x0FA63, (0x5E8, 0x2)),
-    (0x0F920, (0x6D0, 0x2)),
-    (0x0F91F, (0x580, 0x2)),
-    (0x2F97D, (0x50E, 0x2)),
-    (0x0F990, (0x2A4, 0x2)),
-    (0x0FA57, (0x4E4, 0x2)),
-    (0x2F975, (0x786, 0x2)),
-    (0x0FAD8, (0x6E8, 0x2)),
-    (0x0FAB3, (0x54C, 0x2)),
-    (0x2F9F3, (0x67C, 0x2)),
-    (0x0F9FB, (0x3D2, 0x2)),
-    (0x0F918, (0x564, 0x2)),
-    (0x2F8C3, (0x2D8, 0x2)),
-    (0x0F9CA, (0x384, 0x2)),
-    (0x0F952, (0x11E, 0x2)),
-    (0x2FA0B, (0x6C4, 0x2)),
-    (0x2F941, (0x762, 0x2)),
-    (0x2F862, (0x1D4, 0x2)),
-    (0x2F8FF, (0x37A, 0x2)),
-    (0x2F85D, (0x1C2, 0x2)),
-    (0x0F9D9, (0x278, 0x2)),
-    (0x2F855, (0x19C, 0x2)),
-    (0x2F98F, (0x536, 0x2)),
-    (0x0F9D4, (0x0B8, 0x2)),
-    (0x0F99E, (0x168, 0x2)),
-    (0x2F850, (0x0FE, 0x2)),
-    (0x0FA22, (0x5DC, 0x2)),
-    (0x2F94F, (0x46E, 0x2)),
-    (0x0FAA9, (0x460, 0x2)),
-    (0x0FA71, (0x0EA, 0x2)),
-    (0x0F95D, (0x5E0, 0x2)),
-    (0x2F8BD, (0x2D0, 0x2)),
-    (0x2FA02, (0x6AA, 0x2)),
-    (0x2F93F, (0x040, 0x2)),
-    (0x2F808, (0x0BA, 0x2)),
-    (0x2F950, (0x476, 0x2)),
-    (0x2F933, (0x03C, 0x2)),
-    (0x2F853, (0x1A0, 0x2)),
-    (0x2F8F0, (0x73A, 0x2)),
-    (0x0F967, (0x08C, 0x2)),
-    (0x0FA16, (0x402, 0x2)),
-    (0x0FAA6, (0x44C, 0x2)),
-    (0x2F8B3, (0x2A8, 0x2)),
-    (0x2F9F7, (0x7BE, 0x2)),
-    (0x0F986, (0x664, 0x2)),
-    (0x2F99D, (0x554, 0x2)),
-    (0x2F9B8, (0x58E, 0x2)),
-    (0x0F998, (0x616, 0x2)),
-    (0x2F82B, (0x132, 0x2)),
-    (0x2F872, (0x1F8, 0x2)),
-    (0x0FAB9, (0x5D0, 0x2)),
-    (0x0FA9B, (0x3C4, 0x2)),
-    (0x0F9B0, (0x50C, 0x2)),
-    (0x0F98B, (0x308, 0x2)),
-    (0x0FAD1, (0x734, 0x2)),
-    (0x0F917, (0x414, 0x2)),
-    (0x2F989, (0x72E, 0x2)),
-    (0x2F866, (0x1DC, 0x2)),
-    (0x0F932, (0x3E8, 0x2)),
-    (0x2FA0E, (0x086, 0x2)),
-    (0x0FA07, (0x61E, 0x2)),
-    (0x0F9BD, (0x1FE, 0x2)),
-    (0x2F88C, (0x232, 0x2)),
-    (0x0FA56, (0x4B4, 0x2)),
-    (0x0FA64, (0x600, 0x2)),
-    (0x0FA04, (0x1E8, 0x2)),
-    (0x0FA9E, (0x3F0, 0x2)),
-    (0x2F9E0, (0x7B0, 0x2)),
-    (0x2F89D, (0x25C, 0x2)),
-    (0x2F9EE, (0x662, 0x2)),
-    (0x0F9DB, (0x40C, 0x2)),
-    (0x0F923, (0x578, 0x2)),
-    (0x2F841, (0x16A, 0x2)),
-    (0x2F81A, (0x0E8, 0x2)),
-    (0x0F911, (0x5A0, 0x2)),
-    (0x0FAAD, (0x4B6, 0x2)),
-    (0x0FAC1, (0x604, 0x2)),
-    (0x2F928, (0x408, 0x2)),
-    (0x2F935, (0x756, 0x2)),
-    (0x2F8D5, (0x304, 0x2)),
-    (0x0F92E, (0x0EE, 0x2)),
-    (0x0FA59, (0x4EE, 0x2)),
-    (0x2F96B, (0x77E, 0x2)),
-    (0x2F8B9, (0x2BE, 0x2)),
-    (0x2F877, (0x200, 0x2)),
-    (0x2FA00, (0x6A2, 0x2)),
-    (0x0FA05, (0x37E, 0x2)),
-    (0x0F9E8, (0x5B6, 0x2)),
-    (0x2F8C6, (0x2DA, 0x2)),
-    (0x0F97A, (0x334, 0x2)),
-    (0x2F9EA, (0x654, 0x2)),
-    (0x0F944, (0x4BE, 0x2)),
-    (0x2F8C4, (0x2DC, 0x2)),
-    (0x2F9CD, (0x072, 0x2)),
-    (0x2F8E5, (0x330, 0x2)),
-    (0x2F9D9, (0x6FE, 0x2)),
-    (0x2F980, (0x72C, 0x2)),
-    (0x2F9A8, (0x56E, 0x2)),
-    (0x2F92F, (0x41E, 0x2)),
-    (0x2F951, (0x04C, 0x2)),
-    (0x2F9F9, (0x07C, 0x2)),
-    (0x0FAB4, (0x560, 0x2)),
-    (0x0F985, (0x47A, 0x2)),
-    (0x2F829, (0x12C, 0x2)),
-    (0x2F8A2, (0x01A, 0x2)),
-    (0x2F9C3, (0x5AA, 0x2)),
-    (0x2F936, (0x434, 0x2)),
-    (0x2F9AF, (0x068, 0x2)),
-    (0x0FA77, (0x128, 0x2)),
-    (0x0F956, (0x4A0, 0x2)),
-    (0x0FA5F, (0x568, 0x2)),
-    (0x2F93B, (0x75A, 0x2)),
-    (0x0F914, (0x346, 0x2)),
-    (0x2F994, (0x53C, 0x2)),
-    (0x2F91B, (0x6F8, 0x2)),
-    (0x2F880, (0x21A, 0x2)),
-    (0x2F956, (0x498, 0x2)),
-    (0x0F958, (0x562, 0x2)),
-    (0x2F99B, (0x552, 0x2)),
-    (0x2FA06, (0x6B6, 0x2)),
-    (0x0FABF, (0x5EA, 0x2)),
-    (0x2F8B6, (0x2B8, 0x2)),
-    (0x2F8A0, (0x26A, 0x2)),
-    (0x0FA87, (0x280, 0x2)),
-    (0x2F8EA, (0x344, 0x2)),
-    (0x2F867, (0x00A, 0x2)),
-    (0x0F97D, (0x5D4, 0x2)),
-    (0x0F968, (0x374, 0x2)),
-    (0x0FA5A, (0x4F4, 0x2)),
-    (0x0F97B, (0x4CC, 0x2)),
-    (0x2FA10, (0x7C8, 0x2)),
-    (0x0FA2B, (0x6AE, 0x2)),
-    (0x0FA75, (0x0DC, 0x2)),
-    (0x0F94D, (0x398, 0x2)),
-    (0x0FAD4, (0x044, 0x2)),
-    (0x2F8CC, (0x30C, 0x2)),
-    (0x0FA8A, (0x284, 0x2)),
-    (0x0F9F4, (0x328, 0x2)),
-    (0x0FAC6, (0x672, 0x2)),
-    (0x0FA9C, (0x3E0, 0x2)),
-    (0x0FA10, (0x1AA, 0x2)),
-    (0x0F9E2, (0x33C, 0x2)),
-    (0x0F947, (0x472, 0x2)),
-    (0x0F941, (0x5D6, 0x2)),
-    (0x0FA4E, (0x480, 0x2)),
-    (0x2F9DA, (0x60C, 0x2)),
-    (0x2F893, (0x526, 0x2)),
-    (0x0F96F, (0x5CC, 0x2)),
-    (0x0F983, (0x2F0, 0x2)),
-    (0x0F9F5, (0x396, 0x2)),
-    (0x0F962, (0x43A, 0x2)),
-    (0x2F968, (0x4CE, 0x2)),
-    (0x2F923, (0x750, 0x2)),
-    (0x2FA18, (0x6DE, 0x2)),
-    (0x2F930, (0x424, 0x2)),
-    (0x0FA90, (0x2E8, 0x2)),
-    (0x0FA54, (0x4A2, 0x2)),
-    (0x0F9D8, (0x254, 0x2)),
-    (0x2F9E4, (0x63E, 0x2)),
-    (0x2FA05, (0x6B4, 0x2)),
-    (0x2F964, (0x052, 0x2)),
-    (0x0F99F, (0x3D6, 0x2)),
-    (0x2F94B, (0x048, 0x2)),
-    (0x2F9A9, (0x570, 0x2)),
-    (0x0FA0C, (0x0C6, 0x2)),
-    (0x2F986, (0x1DE, 0x2)),
-    (0x0FA85, (0x25A, 0x2)),
-    (0x2F95F, (0x4B0, 0x2)),
-    (0x0F9F8, (0x4B2, 0x2)),
-    (0x0F9B4, (0x6A0, 0x2)),
-    (0x2F82E, (0x13C, 0x2)),
-    (0x0FAD9, (0x6EC, 0x2)),
-    (0x2F937, (0x758, 0x2)),
-    (0x0F9CF, (0x4D2, 0x2)),
-    (0x0FAA1, (0x422, 0x2)),
-    (0x2F917, (0x3CA, 0x2)),
-    (0x0FAA5, (0x444, 0x2)),
-    (0x0FA3B, (0x204, 0x2)),
-    (0x2F88D, (0x234, 0x2)),
-    (0x2F906, (0x742, 0x2)),
-    (0x2F901, (0x390, 0x2)),
-    (0x2F97A, (0x50A, 0x2)),
-    (0x0FA60, (0x5BC, 0x2)),
-    (0x2F92C, (0x038, 0x2)),
-    (0x2F80A, (0x0C4, 0x2)),
-    (0x2F99A, (0x550, 0x2)),
-    (0x2FA13, (0x7CC, 0x2)),
-    (0x2F938, (0x43C, 0x2)),
-    (0x2F813, (0x002, 0x2)),
-    (0x2F831, (0x144, 0x2)),
-    (0x0FA1C, (0x68E, 0x2)),
-    (0x0FACC, (0x6A6, 0x2)),
-    (0x0FA5E, (0x532, 0x2)),
-    (0x2F995, (0x53E, 0x2)),
-    (0x2F8D3, (0x0E2, 0x2)),
-    (0x0FACD, (0x6BE, 0x2)),
-    (0x2F81D, (0x0F8, 0x2)),
-    (0x2F97B, (0x78A, 0x2)),
-    (0x0FA3A, (0x1B0, 0x2)),
-    (0x0F9C6, (0x668, 0x2)),
-    (0x0FABD, (0x5E2, 0x2)),
-    (0x0F92D, (0x0AA, 0x2)),
-    (0x0F99B, (0x65C, 0x2)),
-    (0x0F91D, (0x354, 0x2)),
-    (0x2F84D, (0x19A, 0x2)),
-    (0x2F8AD, (0x292, 0x2)),
-    (0x0F9D3, (0x670, 0x2)),
-    (0x2F843, (0x16E, 0x2)),
-    (0x0F97C, (0x52E, 0x2)),
-    (0x0FA30, (0x0AE, 0x2)),
-    (0x2F858, (0x1B2, 0x2)),
-    (0x2F8A5, (0x270, 0x2)),
-    (0x2F988, (0x792, 0x2)),
-    (0x2F9E1, (0x7B2, 0x2)),
-    (0x0FA74, (0x0C8, 0x2)),
-    (0x2F882, (0x222, 0x2)),
-    (0x2F879, (0x20E, 0x2)),
-    (0x2F8B7, (0x2C0, 0x2)),
-    (0x0F940, (0x6D2, 0x2)),
-    (0x2F9E5, (0x7B4, 0x2)),
-    (0x2F9CF, (0x5CA, 0x2)),
-    (0x0FA8E, (0x2D2, 0x2)),
-    (0x2F90C, (0x3A8, 0x2)),
-    (0x2F985, (0x51E, 0x2)),
-    (0x2F849, (0x184, 0x2)),
-    (0x2F960, (0x050, 0x2)),
-    (0x2F8C2, (0x01E, 0x2)),
-    (0x2F85F, (0x1CE, 0x2)),
-    (0x2F916, (0x034, 0x2)),
-    (0x0F9FA, (0x3FE, 0x2)),
-    (0x2F824, (0x008, 0x2)),
-    (0x0F936, (0x586, 0x2)),
-    (0x2F94A, (0x464, 0x2)),
-    (0x2F80E, (0x0CC, 0x2)),
-    (0x2F913, (0x3C8, 0x2)),
-    (0x2F94D, (0x76A, 0x2)),
-    (0x0F999, (0x56C, 0x2)),
-    (0x2F979, (0x502, 0x2)),
-    (0x2F926, (0x752, 0x2)),
-    (0x0F9EA, (0x67E, 0x2)),
-    (0x0FA3F, (0x28A, 0x2)),
-    (0x2F83B, (0x156, 0x2)),
-    (0x0FA5B, (0x506, 0x2)),
-    (0x0FA93, (0x316, 0x2)),
-    (0x0F913, (0x632, 0x2)),
-    (0x0F98C, (0x35C, 0x2)),
-    (0x2F8C0, (0x2CE, 0x2)),
-    (0x0FAD7, (0x7AC, 0x2)),
-    (0x0F98A, (0x110, 0x2)),
-    (0x0FA26, (0x63C, 0x2)),
-    (0x0FABE, (0x5D8, 0x2)),
-    (0x2F977, (0x788, 0x2)),
-    (0x0F954, (0x0F4, 0x2)),
-    (0x0F91A, (0x6B8, 0x2)),
-    (0x2F8CD, (0x2F8, 0x2)),
-    (0x2F8A4, (0x71E, 0x2)),
-    (0x0FA84, (0x250, 0x2)),
-    (0x2F85E, (0x1C4, 0x2)),
-    (0x0FA9F, (0x3FC, 0x2)),
-    (0x0F9B1, (0x64E, 0x2)),
-    (0x2F9CA, (0x004, 0x2)),
-    (0x0FAC4, (0x644, 0x2)),
-    (0x0F927, (0x5A6, 0x2)),
-    (0x0FA01, (0x22E, 0x2)),
-    (0x0F929, (0x310, 0x2)),
-    (0x0F9F3, (0x6D6, 0x2)),
-    (0x2F9E6, (0x640, 0x2)),
-    (0x0FA70, (0x08E, 0x2)),
-    (0x2F820, (0x106, 0x2)),
-    (0x0F9A9, (0x196, 0x2)),
-    (0x2F9BF, (0x06C, 0x2)),
-    (0x2F922, (0x3F4, 0x2)),
-    (0x2F9DE, (0x614, 0x2)),
-    (0x2F8EC, (0x738, 0x2)),
-    (0x0F9B5, (0x0AC, 0x2)),
-    (0x2F9B7, (0x590, 0x2)),
-    (0x2F981, (0x05C, 0x2)),
-    (0x0FA31, (0x0C2, 0x2)),
-    (0x2F9C1, (0x5A4, 0x2)),
-    (0x2F874, (0x24C, 0x2)),
-    (0x0F9D0, (0x6A8, 0x2)),
-    (0x0F94A, (0x1B6, 0x2)),
-    (0x2F998, (0x542, 0x2)),
-    (0x2F91C, (0x3DA, 0x2)),
-    (0x2F9DF, (0x61C, 0x2)),
-    (0x2F859, (0x706, 0x2)),
-    (0x2F883, (0x010, 0x2)),
-    (0x0F9CC, (0x418, 0x2)),
-    (0x2F9B5, (0x58A, 0x2)),
-    (0x2F970, (0x4F0, 0x2)),
-    (0x2F814, (0x0D2, 0x2)),
-    (0x2F9FF, (0x69E, 0x2)),
-    (0x2F84C, (0x18E, 0x2)),
-    (0x2F9A4, (0x796, 0x2)),
-    (0x2F966, (0x4C6, 0x2)),
-    (0x0FA1E, (0x500, 0x2)),
-    (0x2FA0C, (0x6C8, 0x2)),
-    (0x2F863, (0x1D6, 0x2)),
-    (0x0FAA2, (0x42E, 0x2)),
-    (0x2F91A, (0x3D4, 0x2)),
-    (0x2F8F8, (0x710, 0x2)),
-    (0x2F8A6, (0x27A, 0x2)),
-    (0x2F895, (0x24A, 0x2)),
-    (0x0F90B, (0x178, 0x2)),
-    (0x2F993, (0x53A, 0x2)),
-    (0x2F8BE, (0x726, 0x2)),
-    (0x0F948, (0x5FC, 0x2)),
-    (0x2F80D, (0x6FC, 0x2)),
-    (0x2F81F, (0x006, 0x2)),
-    (0x0F9E4, (0x416, 0x2)),
-    (0x2F823, (0x10C, 0x2)),
-    (0x2F9FA, (0x694, 0x2)),
-    (0x2F8FA, (0x36C, 0x2)),
-    (0x0FA6A, (0x6A4, 0x2)),
-    (0x2F9F0, (0x666, 0x2)),
-    (0x2F967, (0x054, 0x2)),
-    (0x0FA8F, (0x2D6, 0x2)),
-    (0x0FA06, (0x306, 0x2)),
-    (0x0F982, (0x242, 0x2)),
-    (0x0F989, (0x6DA, 0x2)),
-    (0x2F990, (0x534, 0x2)),
-    (0x0FAC9, (0x692, 0x2)),
-    (0x2F8ED, (0x352, 0x2)),
-    (0x2F822, (0x10A, 0x2)),
-    (0x0F9CB, (0x3A4, 0x2)),
-    (0x0FA4D, (0x482, 0x2)),
-    (0x2F944, (0x766, 0x2)),
-    (0x2F9E8, (0x656, 0x2)),
-    (0x2F8D2, (0x0E0, 0x2)),
-    (0x2F97C, (0x78C, 0x2)),
-    (0x0FA68, (0x680, 0x2)),
-    (0x0FA53, (0x494, 0x2)),
-    (0x2F8F5, (0x368, 0x2)),
-    (0x2F945, (0x458, 0x2)),
-    (0x0FA95, (0x35E, 0x2)),
-    (0x0FA2E, (0x638, 0x2)),
-    (0x0F91B, (0x09A, 0x2)),
-    (0x2F837, (0x14E, 0x2)),
-    (0x2F894, (0x248, 0x2)),
-    (0x2FA09, (0x7C6, 0x2)),
-    (0x2F974, (0x05A, 0x2)),
-    (0x0F9BA, (0x09C, 0x2)),
-    (0x2F80B, (0x0BE, 0x2)),
-    (0x0FACA, (0x698, 0x2)),
-    (0x2F969, (0x4CA, 0x2)),
-    (0x2F8B1, (0x2A2, 0x2)),
-    (0x2F8D1, (0x022, 0x2)),
-    (0x2F91D, (0x74A, 0x2)),
-    (0x2F9D4, (0x5F8, 0x2)),
-    (0x2FA15, (0x6D8, 0x2)),
-    (0x2F954, (0x76E, 0x2)),
-    (0x0FA81, (0x1E2, 0x2)),
-    (0x2F9A5, (0x79A, 0x2)),
-    (0x2F90F, (0x3BA, 0x2)),
-    (0x0F92A, (0x38C, 0x2)),
-    (0x2FA19, (0x6E0, 0x2)),
-    (0x2F943, (0x764, 0x2)),
-    (0x2F947, (0x45C, 0x2)),
-    (0x2FA0A, (0x6C0, 0x2)),
-    (0x2F963, (0x4BA, 0x2)),
-    (0x0F9BB, (0x0C0, 0x2)),
-    (0x2F8AC, (0x296, 0x2)),
-    (0x0F9C5, (0x2FE, 0x2)),
-    (0x2F97E, (0x78E, 0x2)),
-    (0x2F889, (0x716, 0x2)),
-    (0x2F8E9, (0x342, 0x2)),
-    (0x0F9DA, (0x32E, 0x2)),
-    (0x0FACE, (0x6F2, 0x2)),
-    (0x2F920, (0x3EC, 0x2)),
-    (0x0F951, (0x66A, 0x2)),
-    (0x0F9BC, (0x1F4, 0x2)),
-    (0x2F940, (0x454, 0x2)),
-    (0x2F84E, (0x190, 0x2)),
-    (0x0FA48, (0x3DE, 0x2)),
-    (0x2FA08, (0x082, 0x2)),
-    (0x0F9E6, (0x4F6, 0x2)),
-    (0x2F8C8, (0x2E6, 0x2)),
-    (0x0F912, (0x5B8, 0x2)),
-    (0x2F8F7, (0x73C, 0x2)),
-    (0x2F904, (0x392, 0x2)),
-    (0x0FA76, (0x116, 0x2)),
-    (0x2F8E8, (0x340, 0x2)),
-    (0x2F9E2, (0x634, 0x2)),
-    (0x0F903, (0x5FE, 0x2)),
-    (0x0FA9A, (0x3B6, 0x2)),
-    (0x0F996, (0x4E2, 0x2)),
-    (0x2F8DB, (0x322, 0x2)),
-    (0x0FA4A, (0x41A, 0x2)),
-    (0x0FA6B, (0x268, 0x2)),
-    (0x2F8FD, (0x376, 0x2)),
-    (0x0FA79, (0x170, 0x2)),
-    (0x0F987, (0x6BC, 0x2)),
-    (0x2F8F2, (0x030, 0x2)),
-    (0x0F90D, (0x2A0, 0x2)),
-    (0x0F922, (0x3BE, 0x2)),
-    (0x0FA88, (0x276, 0x2)),
-    (0x0F91C, (0x140, 0x2)),
-    (0x2F870, (0x1F6, 0x2)),
-    (0x2F9AC, (0x576, 0x2)),
-    (0x2F839, (0x152, 0x2)),
-    (0x2FA03, (0x080, 0x2)),
-    (0x2F854, (0x1A2, 0x2)),
-    (0x2F92A, (0x036, 0x2)),
-    (0x0FA35, (0x138, 0x2)),
-    (0x2F9E7, (0x650, 0x2)),
-    (0x2F9A6, (0x798, 0x2)),
-    (0x0FAAF, (0x4D8, 0x2)),
-    (0x2F911, (0x748, 0x2)),
-    (0x2F95D, (0x774, 0x2)),
-    (0x2F89C, (0x256, 0x2)),
-    (0x0FA45, (0x38E, 0x2)),
-    (0x0FA1B, (0x496, 0x2)),
-    (0x0FA3D, (0x26C, 0x2)),
-    (0x0F980, (0x15E, 0x2)),
-    (0x0FA8C, (0x2AC, 0x2)),
-    (0x2F9E9, (0x658, 0x2)),
-    (0x2F9F8, (0x07A, 0x2)),
-    (0x2F902, (0x388, 0x2)),
-    (0x2FA1D, (0x7D2, 0x2)),
-    (0x0FAB6, (0x5BE, 0x2)),
-    (0x0F995, (0x49C, 0x2)),
-    (0x2F832, (0x146, 0x2)),
-    (0x2F955, (0x770, 0x2)),
-    (0x2F8FC, (0x372, 0x2)),
-    (0x2F875, (0x1FC, 0x2)),
-    (0x2F82A, (0x12E, 0x2)),
-    (0x2F811, (0x0DA, 0x2)),
-    (0x2F868, (0x00C, 0x2)),
-    (0x2F925, (0x3FA, 0x2)),
-    (0x0FA20, (0x57E, 0x2)),
-    (0x2F83E, (0x160, 0x2)),
-    (0x0F9AF, (0x4FE, 0x2)),
-    (0x2F997, (0x794, 0x2)),
-    (0x2F9EC, (0x660, 0x2)),
-    (0x0F9AB, (0x21E, 0x2)),
-    (0x0F935, (0x57C, 0x2)),
-    (0x0FA80, (0x1DA, 0x2)),
-    (0x2F95C, (0x772, 0x2)),
-    (0x0FA92, (0x312, 0x2)),
-    (0x0F95B, (0x2B4, 0x2)),
-    (0x0F93E, (0x556, 0x2)),
-    (0x0F9DE, (0x158, 0x2)),
-    (0x0F9F0, (0x57A, 0x2)),
-    (0x2F847, (0x17C, 0x2)),
-    (0x0FA98, (0x3B0, 0x2)),
-    (0x0F90E, (0x448, 0x2)),
-    (0x0FA4F, (0x484, 0x2)),
-    (0x0FAA4, (0x442, 0x2)),
-    (0x2F9C0, (0x5A2, 0x2)),
-    (0x2F8BF, (0x2D4, 0x2)),
-    (0x0FA62, (0x5E4, 0x2)),
-    (0x0F9B6, (0x49A, 0x2)),
-    (0x2F826, (0x11C, 0x2)),
-    (0x0F9C9, (0x32A, 0x2)),
-    (0x2F992, (0x114, 0x2)),
-    (0x2F8E1, (0x332, 0x2)),
-    (0x0F959, (0x66E, 0x2)),
-    (0x2F892, (0x71C, 0x2)),
-    (0x0FA18, (0x47C, 0x2)),
-    (0x2F87D, (0x714, 0x2)),
-    (0x0F970, (0x364, 0x2)),
-    (0x2F92B, (0x410, 0x2)),
-    (0x2FA04, (0x6B2, 0x2)),
-    (0x0FA89, (0x28C, 0x2)),
-    (0x2F9E3, (0x63A, 0x2)),
-    (0x2F9C2, (0x06E, 0x2)),
-    (0x0FACB, (0x69A, 0x2)),
-    (0x2F9C8, (0x070, 0x2)),
-    (0x2F908, (0x3A0, 0x2)),
-    (0x2F86F, (0x1F2, 0x2)),
-    (0x2F98A, (0x730, 0x2)),
-    (0x0F9A8, (0x0A4, 0x2)),
-    (0x2F8C7, (0x020, 0x2)),
-    (0x2FA16, (0x08A, 0x2)),
-    (0x0FA4B, (0x470, 0x2)),
-    (0x2F878, (0x20A, 0x2)),
-    (0x2F8BB, (0x2C2, 0x2)),
-    (0x2F816, (0x6FA, 0x2)),
-    (0x2F86A, (0x1E4, 0x2)),
-    (0x0F9C3, (0x630, 0x2)),
-    (0x0F945, (0x514, 0x2)),
-    (0x2F9FE, (0x69C, 0x2)),
-    (0x0FA86, (0x272, 0x2)),
-    (0x2F82C, (0x136, 0x2)),
-    (0x0F988, (0x6D4, 0x2)),
-    (0x0FAC5, (0x652, 0x2)),
-    (0x0FA66, (0x626, 0x2)),
-    (0x2F840, (0x166, 0x2)),
-    (0x0F9EE, (0x3E6, 0x2)),
-    (0x2F830, (0x142, 0x2)),
-    (0x2F914, (0x3C6, 0x2)),
-    (0x2F942, (0x760, 0x2)),
-    (0x0FAA3, (0x432, 0x2)),
-    (0x0F974, (0x540, 0x2)),
-    (0x2F807, (0x0B6, 0x2)),
-    (0x2F905, (0x394, 0x2)),
-    (0x2F9B2, (0x06A, 0x2)),
-    (0x2F887, (0x22A, 0x2)),
-    (0x2F912, (0x3BC, 0x2)),
-    (0x0F9AE, (0x420, 0x2)),
-    (0x0F96A, (0x4D4, 0x2)),
-    (0x0F9B7, (0x646, 0x2)),
-    (0x2F932, (0x42C, 0x2)),
-    (0x2F98D, (0x622, 0x2)),
-    (0x0FA25, (0x62A, 0x2)),
-    (0x0F993, (0x3DC, 0x2)),
-    (0x2F9F5, (0x688, 0x2)),
-    (0x0F9DF, (0x206, 0x2)),
-    (0x2F9C7, (0x5B4, 0x2)),
-    (0x2F996, (0x544, 0x2)),
-    (0x2F842, (0x16C, 0x2)),
-    (0x2F869, (0x1E0, 0x2)),
-    (0x2F861, (0x70A, 0x2)),
-    (0x2F8AF, (0x298, 0x2)),
-    (0x2F8C5, (0x2E0, 0x2)),
-    (0x2F962, (0x4B8, 0x2)),
-    (0x2F98B, (0x528, 0x2)),
-    (0x2F9A1, (0x558, 0x2)),
-    (0x0FAD2, (0x02A, 0x2)),
-    (0x2F9AE, (0x066, 0x2)),
-    (0x2F8BC, (0x2C6, 0x2)),
-    (0x0F9B3, (0x68C, 0x2)),
-    (0x2F88F, (0x7D0, 0x2)),
-    (0x0F965, (0x0B4, 0x2)),
-    (0x2F953, (0x488, 0x2)),
-    (0x2F84B, (0x198, 0x2)),
-    (0x2F90B, (0x3AC, 0x2)),
-    (0x2F834, (0x702, 0x2)),
-    (0x0FA2D, (0x6CC, 0x2)),
-    (0x2F8E6, (0x33E, 0x2)),
-    (0x0F971, (0x624, 0x2)),
-    (0x2FA1C, (0x6E6, 0x2)),
-    (0x0FA61, (0x5C6, 0x2)),
-    (0x2F98E, (0x062, 0x2)),
-    (0x2F9C9, (0x5BA, 0x2)),
-    (0x0FA0B, (0x23E, 0x2)),
-    (0x2F86B, (0x1E6, 0x2)),
-    (0x0F949, (0x686, 0x2)),
-    (0x0FAC7, (0x682, 0x2)),
-    (0x0F96E, (0x566, 0x2)),
-    (0x0F966, (0x258, 0x2)),
-    (0x0F955, (0x0F2, 0x2)),
-    (0x2F8D0, (0x024, 0x2)),
-    (0x2F93A, (0x440, 0x2)),
-    (0x0F9FF, (0x104, 0x2)),
-    (0x0FAC8, (0x690, 0x2)),
-    (0x0F93C, (0x490, 0x2)),
-    (0x2F845, (0x174, 0x2)),
-    (0x2F9CE, (0x074, 0x2)),
-    (0x0FAD6, (0x77C, 0x2)),
-    (0x2F95A, (0x4A6, 0x2)),
-    (0x0F9E9, (0x648, 0x2)),
-    (0x2F91F, (0x74E, 0x2)),
-    (0x0F950, (0x4EC, 0x2)),
-    (0x2F8C1, (0x2CA, 0x2)),
-    (0x2F9AD, (0x79C, 0x2)),
-    (0x2F97F, (0x512, 0x2)),
-    (0x0FA83, (0x240, 0x2)),
-    (0x2F82D, (0x13A, 0x2)),
-    (0x2F8DF, (0x32C, 0x2)),
-    (0x2F87C, (0x212, 0x2)),
-    (0x0FA58, (0x4EA, 0x2)),
-    (0x2F846, (0x176, 0x2)),
-    (0x0FA37, (0x18C, 0x2)),
-    (0x0FA78, (0x180, 0x2)),
-    (0x2F9F6, (0x7BA, 0x2)),
-    (0x2F99E, (0x55E, 0x2)),
-    (0x0FAD3, (0x042, 0x2)),
-    (0x0FAD0, (0x720, 0x2)),
-    (0x0F9D5, (0x210, 0x2)),
-    (0x0FAB7, (0x5C2, 0x2)),
-    (0x0FA09, (0x66C, 0x2)),
-    (0x2F8CE, (0x026, 0x2)),
-    (0x0F957, (0x4DE, 0x2)),
-    (0x0F991, (0x2DE, 0x2)),
-    (0x0FAB8, (0x5C8, 0x2)),
-    (0x2F8EB, (0x34E, 0x2)),
-    (0x2F9B1, (0x7A0, 0x2)),
-    (0x0FA2A, (0x6AC, 0x2)),
-    (0x2F93C, (0x75C, 0x2)),
-    (0x0FA72, (0x0D4, 0x2)),
-    (0x2F96F, (0x4E8, 0x2)),
-    (0x2F8D6, (0x518, 0x2)),
-    (0x2F886, (0x228, 0x2)),
-    (0x0F9FD, (0x0A0, 0x2)),
-    (0x0F9C0, (0x3E4, 0x2)),
-    (0x2F9BE, (0x59E, 0x2)),
-    (0x0F9B8, (0x67A, 0x2)),
-    (0x2F81E, (0x0FA, 0x2)),
-    (0x0F900, (0x5F4, 0x2)),
-    (0x2F98C, (0x52A, 0x2)),
-    (0x2F93E, (0x03E, 0x2)),
-    (0x0FAA0, (0x404, 0x2)),
-    (0x2F8F3, (0x35A, 0x2)),
-    (0x0F961, (0x40A, 0x2)),
-    (0x2F83D, (0x15C, 0x2)),
-    (0x2F8F6, (0x36A, 0x2)),
-    (0x0F9D2, (0x2AA, 0x2)),
-    (0x2F84A, (0x188, 0x2)),
-    (0x0F9E1, (0x31C, 0x2)),
-    (0x0FA7C, (0x1AC, 0x2)),
-    (0x2F9AA, (0x574, 0x2)),
-    (0x0FA51, (0x48A, 0x2)),
-    (0x2F8B8, (0x724, 0x2)),
-    (0x2F931, (0x426, 0x2)),
-    (0x0FA7E, (0x1C6, 0x2)),
-    (0x0F9A6, (0x4BC, 0x2)),
-    (0x0F976, (0x438, 0x2)),
-    (0x0FA97, (0x386, 0x2)),
-    (0x2F8E7, (0x02C, 0x2)),
-    (0x2F88B, (0x230, 0x2)),
-    (0x2F9C6, (0x5B2, 0x2)),
-    (0x2F8D9, (0x318, 0x2)),
-    (0x0FA52, (0x492, 0x2)),
-    (0x2FA0D, (0x084, 0x2)),
-    (0x2F900, (0x382, 0x2)),
-    (0x2F836, (0x14C, 0x2)),
-    (0x0F9AD, (0x412, 0x2)),
-    (0x0F934, (0x504, 0x2)),
-    (0x0FAB0, (0x4E6, 0x2)),
-    (0x2F809, (0x0BC, 0x2)),
-    (0x2F9F2, (0x078, 0x2)),
-    (0x2F86C, (0x70C, 0x2)),
-    (0x0F9FC, (0x5EC, 0x2)),
-    (0x2F95E, (0x776, 0x2)),
-    (0x0F9A3, (0x260, 0x2)),
-    (0x2F971, (0x058, 0x2)),
-    (0x2F89B, (0x018, 0x2)),
-    (0x0F977, (0x09E, 0x2)),
-    (0x0FA1A, (0x48E, 0x2)),
-    (0x0FA3C, (0x208, 0x2)),
-    (0x2F9BD, (0x598, 0x2)),
-    (0x0F928, (0x238, 0x2)),
-    (0x2F864, (0x1D8, 0x2)),
-    (0x2F9D1, (0x5F2, 0x2)),
-    (0x2F982, (0x51A, 0x2)),
-    (0x0F9DC, (0x674, 0x2)),
-    (0x2F972, (0x782, 0x2)),
-    (0x2F8CB, (0x2F4, 0x2)),
-    (0x0F960, (0x264, 0x2)),
-    (0x0F992, (0x3B8, 0x2)),
-    (0x2F8B4, (0x2AE, 0x2)),
-    (0x2F803, (0x6F4, 0x2)),
-    (0x2F818, (0x0E6, 0x2)),
-    (0x0F9F7, (0x4AE, 0x2)),
-    (0x2F827, (0x124, 0x2)),
-    (0x2F9FB, (0x7C0, 0x2)),
-    (0x2F987, (0x790, 0x2)),
-    (0x0FAAB, (0x474, 0x2)),
-    (0x0FA39, (0x1A8, 0x2)),
-    (0x2FA07, (0x6BA, 0x2)),
-    (0x0F9B9, (0x274, 0x2)),
-    (0x2F86E, (0x1EC, 0x2)),
-    (0x2F8E0, (0x326, 0x2)),
-    (0x0FAA7, (0x44E, 0x2)),
-    (0x2F8A8, (0x282, 0x2)),
-    (0x0FA0A, (0x5C4, 0x2)),
-    (0x2FA14, (0x7CE, 0x2)),
-    (0x2F888, (0x012, 0x2)),
-    (0x2F9A2, (0x55A, 0x2)),
-    (0x2F848, (0x182, 0x2)),
-    (0x0FAA8, (0x452, 0x2)),
-    (0x0FA67, (0x62C, 0x2)),
-    (0x0F946, (0x3F6, 0x2)),
-    (0x2F946, (0x45A, 0x2)),
-    (0x0FA7D, (0x1B4, 0x2)),
-    (0x0FA1D, (0x4C4, 0x2)),
-    (0x2FA11, (0x088, 0x2)),
-    (0x0FA2C, (0x6B0, 0x2)),
-    (0x0F924, (0x5C0, 0x2)),
-    (0x2F96E, (0x4E0, 0x2)),
-    (0x0F96D, (0x456, 0x2)),
-    (0x0F95A, (0x5EE, 0x2)),
-    (0x2F85C, (0x1C0, 0x2)),
-    (0x0F92B, (0x400, 0x2)),
-    (0x0FAC0, (0x5F0, 0x2)),
-    (0x0FA8D, (0x2CC, 0x2)),
-    (0x2F9D8, (0x7AE, 0x2)),
-    (0x0F938, (0x68A, 0x2)),
-    (0x2F821, (0x108, 0x2)),
-    (0x0F9AA, (0x1F0, 0x2)),
-    (0x0F9CE, (0x46A, 0x2)),
-    (0x0FA47, (0x3B4, 0x2)),
-    (0x2F8AA, (0x288, 0x2)),
-    (0x2F918, (0x3D0, 0x2)),
-    (0x2F8EE, (0x02E, 0x2)),
-    (0x0F96B, (0x14A, 0x2)),
-    (0x0F909, (0x1CA, 0x2)),
-    (0x2F87F, (0x216, 0x2)),
-    (0x0F908, (0x6F0, 0x2)),
-    (0x0FA5D, (0x530, 0x2)),
-    (0x0F9AC, (0x266, 0x2)),
-    (0x2F896, (0x016, 0x2)),
-    (0x2F9B0, (0x79E, 0x2)),
-    (0x0F9A7, (0x406, 0x2)),
-    (0x0F99D, (0x112, 0x2)),
-    (0x2F957, (0x49E, 0x2)),
-    (0x0F905, (0x090, 0x2)),
-    (0x2F9BC, (0x596, 0x2)),
-    (0x2F8F9, (0x73E, 0x2)),
-    (0x2F8B0, (0x29E, 0x2)),
-    (0x2F881, (0x220, 0x2)),
-    (0x2FA1B, (0x6E4, 0x2)),
-    (0x2F9DD, (0x700, 0x2)),
-    (0x2F9ED, (0x7B6, 0x2)),
-    (0x2F871, (0x70E, 0x2)),
-    (0x2F8AB, (0x28E, 0x2)),
-    (0x2F812, (0x6F6, 0x2)),
-    (0x0F933, (0x450, 0x2)),
-    (0x0F9F2, (0x6C6, 0x2)),
-    (0x0F984, (0x3C0, 0x2)),
-    (0x2F90E, (0x39C, 0x2)),
-    (0x0FAB2, (0x508, 0x2)),
-    (0x0FA32, (0x0CA, 0x2)),
-    (0x2F96D, (0x056, 0x2)),
-    (0x2F9A7, (0x064, 0x2)),
-    (0x0F94F, (0x4D6, 0x2)),
-    (0x2FA0F, (0x6CA, 0x2)),
-    (0x0F925, (0x2B2, 0x2)),
-    (0x0FA91, (0x2FC, 0x2)),
-    (0x0F972, (0x370, 0x2)),
-    (0x0F90A, (0x64C, 0x2)),
-    (0x0FA02, (0x2B6, 0x2)),
-    (0x0F92F, (0x120, 0x2)),
-    (0x0F9DD, (0x102, 0x2)),
-    (0x0FA17, (0x44A, 0x2)),
-    (0x0F93F, (0x65A, 0x2)),
-    (0x2F898, (0x780, 0x2)),
-    (0x2F907, (0x380, 0x2)),
-    (0x0F9EC, (0x3A6, 0x2)),
-    (0x0F9E3, (0x378, 0x2)),
-    (0x0FAB5, (0x59A, 0x2)),
-    (0x0FA40, (0x29A, 0x2)),
-    (0x2F815, (0x0DE, 0x2)),
-    (0x2F9DB, (0x60A, 0x2)),
-    (0x0F91E, (0x3EA, 0x2)),
-    (0x0F92C, (0x636, 0x2)),
-    (0x2F884, (0x224, 0x2)),
-    (0x0FA46, (0x39E, 0x2)),
-    (0x2F9B3, (0x584, 0x2)),
-    (0x2F85B, (0x1BE, 0x2)),
-    (0x0F9CD, (0x436, 0x2)),
-    (0x0F93A, (0x6CE, 0x2)),
-    (0x0F97E, (0x64A, 0x2)),
-    (0x0FA3E, (0x286, 0x2)),
-    (0x2F9EB, (0x65E, 0x2)),
-    (0x2F8E2, (0x338, 0x2)),
-    (0x2F9B6, (0x58C, 0x2)),
-    (0x0F916, (0x3D8, 0x2)),
-    (0x2F8DE, (0x028, 0x2)),
-    (0x0F98F, (0x290, 0x2)),
-    (0x0FA12, (0x2FA, 0x2)),
-    (0x0FA44, (0x336, 0x2)),
-    (0x0F981, (0x1D0, 0x2)),
-    (0x2F9DC, (0x610, 0x2)),
-    (0x0F95C, (0x348, 0x2)),
-    (0x0F937, (0x60E, 0x2)),
-    (0x2F87A, (0x20C, 0x2)),
-    (0x2F903, (0x38A, 0x2)),
-    (0x2F9C5, (0x7A4, 0x2)),
-    (0x2F8CF, (0x302, 0x2)),
-    (0x2F909, (0x3A2, 0x2)),
-    (0x2F991, (0x538, 0x2)),
-    (0x0FA65, (0x602, 0x2)),
-    (0x0FA73, (0x0A8, 0x2)),
-    (0x2F88E, (0x23A, 0x2)),
-    (0x0F9EF, (0x42A, 0x2)),
-    (0x2F9CB, (0x7A6, 0x2)),
-    (0x2F9A3, (0x55C, 0x2)),
-    (0x2F99C, (0x548, 0x2)),
-    (0x2F919, (0x3CE, 0x2)),
-    (0x2F857, (0x1A4, 0x2)),
-    (0x2F96C, (0x4DA, 0x2)),
-    (0x2F800, (0x096, 0x2)),
-    (0x2FA1A, (0x6E2, 0x2)),
-    (0x0F97F, (0x126, 0x2)),
-    (0x0FABA, (0x5DE, 0x2)),
-    (0x0FA82, (0x23C, 0x2)),
-    (0x2F92E, (0x41C, 0x2)),
-    (0x0F9FE, (0x54A, 0x2)),
-    (0x0F994, (0x428, 0x2)),
-    (0x2F83C, (0x164, 0x2)),
-    (0x0FA50, (0x486, 0x2)),
-    (0x2F817, (0x0E4, 0x2)),
-    (0x0FA38, (0x192, 0x2)),
-    (0x0FA69, (0x696, 0x2)),
-    (0x0FAAC, (0x4AC, 0x2)),
-    (0x0F901, (0x30A, 0x2)),
-    (0x0FA33, (0x11A, 0x2)),
-    (0x0F9BF, (0x34A, 0x2)),
-    (0x0F9D1, (0x0D8, 0x2)),
-    (0x0F95F, (0x1EE, 0x2)),
-    (0x2F82F, (0x13E, 0x2)),
-    (0x0F9A4, (0x2C4, 0x2)),
-    (0x2F89E, (0x25E, 0x2)),
-    (0x2F801, (0x092, 0x2)),
-    (0x2F84F, (0x194, 0x2)),
-    (0x2F961, (0x778, 0x2)),
-    (0x2F87E, (0x218, 0x2)),
-    (0x2F9D5, (0x5FA, 0x2)),
-    (0x0F9E7, (0x5B0, 0x2)),
-    (0x0F973, (0x2BC, 0x2)),
-    (0x0F9C2, (0x572, 0x2)),
-    (0x2F9D0, (0x5DA, 0x2)),
-    (0x0F9A5, (0x362, 0x2)),
-    (0x2F80C, (0x000, 0x2)),
-    (0x0F930, (0x2E2, 0x2)),
-    (0x2F8A1, (0x01C, 0x2)),
-    (0x2F828, (0x12A, 0x2)),
-    (0x2F89F, (0x262, 0x2)),
-    (0x0F964, (0x478, 0x2)),
-    (0x0F94E, (0x3B2, 0x2)),
-    (0x2F8D7, (0x05E, 0x2)),
-    (0x2F806, (0x0B2, 0x2)),
-    (0x2F9CC, (0x7A8, 0x2)),
-    (0x2F94E, (0x468, 0x2)),
-    (0x2F929, (0x40E, 0x2)),
-    (0x0FA34, (0x122, 0x2)),
-    (0x2F939, (0x718, 0x2)),
-    (0x0F910, (0x582, 0x2)),
-    (0x0F926, (0x520, 0x2)),
-    (0x0F9A2, (0x236, 0x2)),
-    (0x0FA49, (0x3EE, 0x2)),
-    (0x0F953, (0x516, 0x2)),
-    (0x2F80F, (0x0CE, 0x2)),
-    (0x0F963, (0x130, 0x2)),
-    (0x2F8D4, (0x30E, 0x2)),
-    (0x0F9B2, (0x684, 0x2)),
-    (0x2F973, (0x784, 0x2)),
-    (0x2F897, (0x72A, 0x2)),
-    (0x2F9FC, (0x07E, 0x2)),
-    (0x0F99A, (0x628, 0x2)),
-    (0x2F85A, (0x1BC, 0x2)),
-    (0x0FACF, (0x722, 0x2)),
-    (0x2F9AB, (0x7A2, 0x2)),
-    (0x2F927, (0x754, 0x2)),
-    (0x2F9FD, (0x7C2, 0x2)),
-    (0x0FA36, (0x17E, 0x2)),
-    (0x0F904, (0x3AE, 0x2)),
-    (0x2F81C, (0x7BC, 0x2)),
-    (0x0FA7B, (0x18A, 0x2)),
-    (0x0FA41, (0x2E4, 0x2)),
-    (0x2F87B, (0x712, 0x2)),
-    (0x2F9BA, (0x592, 0x2)),
-    (0x0F979, (0x0F0, 0x2)),
-    (0x0F9D7, (0x618, 0x2)),
-];
-
-pub(crate) const COMBINING_MARK_SALT: &[u16] = &[
-    0x000, 0x000, 0x002, 0x001, 0x008, 0x005, 0x969, 0x1EE, 0x007, 0x0CD, 0x2D9, 0x012, 0x003,
-    0x000, 0x000, 0x2D4, 0x000, 0x0C7, 0x14A, 0x000, 0x001, 0x38A, 0x000, 0x000, 0x007, 0x083,
-    0x00A, 0x000, 0x000, 0x000, 0x001, 0x02B, 0x05D, 0x000, 0x000, 0x000, 0x0A0, 0x000, 0x005,
-    0x000, 0x04B, 0x15D, 0x000, 0x023, 0x0BA, 0x000, 0x000, 0x000, 0x000, 0x058, 0x005, 0x002,
-    0x005, 0x000, 0x064, 0x002, 0x000, 0x002, 0x019, 0x000, 0x001, 0x0EC, 0x001, 0x103, 0x026,
-    0x011, 0x000, 0x001, 0x000, 0x000, 0x040, 0x003, 0x01C, 0x001, 0x023, 0x000, 0x002, 0x001,
-    0x014, 0x000, 0x0B4, 0x000, 0x0A0, 0x0D8, 0x000, 0x003, 0x003, 0x08C, 0x02E, 0x000, 0x000,
-    0x00E, 0x009, 0x000, 0x000, 0x02E, 0x001, 0x001, 0x000, 0x000, 0x000, 0x079, 0x001, 0x000,
-    0x000, 0x036, 0x000, 0x001, 0x000, 0x000, 0x004, 0x03A, 0x000, 0x001, 0x01C, 0x180, 0x002,
-    0x006, 0x0CA, 0x002, 0x000, 0x000, 0x000, 0x000, 0x076, 0x083, 0x000, 0x007, 0x07A, 0x000,
-    0x018, 0x009, 0x070, 0x0AA, 0x000, 0x00F, 0x03C, 0x002, 0x000, 0x008, 0x000, 0x021, 0x008,
-    0x03D, 0x019, 0x017, 0x003, 0x003, 0x017, 0x003, 0x018, 0x000, 0x000, 0x006, 0x001, 0x002,
-    0x000, 0x004, 0x000, 0x004, 0x011, 0x034, 0x000, 0x004, 0x000, 0x000, 0x000, 0x000, 0x013,
-    0x002, 0x000, 0x003, 0x016, 0x000, 0x007, 0x033, 0x006, 0x021, 0x007, 0x008, 0x024, 0x000,
-    0x000, 0x003, 0x00B, 0x003, 0x006, 0x000, 0x0CB, 0x001, 0x000, 0x012, 0x000, 0x000, 0x000,
-    0x01F, 0x00A, 0x024, 0x014, 0x054, 0x000, 0x000, 0x000, 0x000, 0x00D, 0x001, 0x029, 0x000,
-    0x00B, 0x000, 0x001, 0x000, 0x017, 0x001, 0x012, 0x01B, 0x003, 0x000, 0x005, 0x000, 0x001,
-    0x003, 0x001, 0x047, 0x000, 0x02C, 0x006, 0x000, 0x05B, 0x01F, 0x000, 0x000, 0x000, 0x004,
-    0x001, 0x000, 0x003, 0x000, 0x008, 0x001, 0x028, 0x001, 0x001, 0x000, 0x000, 0x000, 0x005,
-    0x003, 0x005, 0x02A, 0x001, 0x002, 0x000, 0x016, 0x015, 0x022, 0x000, 0x000, 0x01A, 0x009,
-    0x00A, 0x000, 0x000, 0x001, 0x00D, 0x000, 0x005, 0x001, 0x001, 0x001, 0x000, 0x000, 0x000,
-    0x000, 0x001, 0x005, 0x03A, 0x000, 0x010, 0x002, 0x004, 0x000, 0x000, 0x03A, 0x000, 0x015,
-    0x002, 0x004, 0x000, 0x000, 0x01A, 0x00A, 0x000, 0x00B, 0x000, 0x000, 0x006, 0x002, 0x000,
-    0x012, 0x000, 0x012, 0x000, 0x003, 0x01F, 0x006, 0x00C, 0x000, 0x000, 0x022, 0x000, 0x002,
-    0x0A0, 0x00C, 0x003, 0x001, 0x039, 0x004, 0x003, 0x00B, 0x008, 0x009, 0x002, 0x000, 0x000,
-    0x000, 0x000, 0x003, 0x002, 0x000, 0x004, 0x00B, 0x003, 0x000, 0x000, 0x005, 0x000, 0x005,
-    0x000, 0x01B, 0x000, 0x000, 0x02A, 0x01E, 0x001, 0x001, 0x000, 0x003, 0x031, 0x001, 0x004,
-    0x010, 0x000, 0x005, 0x001, 0x00D, 0x000, 0x00F, 0x002, 0x000, 0x000, 0x002, 0x000, 0x008,
-    0x00C, 0x000, 0x00E, 0x003, 0x000, 0x000, 0x017, 0x000, 0x001, 0x000, 0x001, 0x001, 0x000,
-    0x000, 0x002, 0x008, 0x007, 0x002, 0x037, 0x000, 0x01C, 0x00D, 0x000, 0x00A, 0x000, 0x000,
-    0x007, 0x023, 0x000, 0x004, 0x000, 0x000, 0x000, 0x019, 0x006, 0x000, 0x002, 0x000, 0x048,
-    0x005, 0x000, 0x000, 0x020, 0x000, 0x000, 0x00A, 0x002, 0x000, 0x01C, 0x008, 0x031, 0x000,
-    0x000, 0x000, 0x00C, 0x00B, 0x002, 0x000, 0x000, 0x000, 0x000, 0x000, 0x004, 0x000, 0x01E,
-    0x000, 0x016, 0x000, 0x000, 0x016, 0x028, 0x000, 0x000, 0x000, 0x03A, 0x000, 0x001, 0x000,
-    0x004, 0x000, 0x000, 0x000, 0x006, 0x002, 0x000, 0x011, 0x00B, 0x000, 0x007, 0x004, 0x000,
-    0x00C, 0x000, 0x026, 0x036, 0x007, 0x002, 0x007, 0x00E, 0x002, 0x001, 0x00A, 0x000, 0x00E,
-    0x002, 0x005, 0x008, 0x002, 0x002, 0x000, 0x000, 0x023, 0x005, 0x005, 0x00E, 0x005, 0x009,
-    0x000, 0x00A, 0x004, 0x001, 0x006, 0x000, 0x000, 0x011, 0x000, 0x002, 0x000, 0x00E, 0x005,
-    0x001, 0x000, 0x002, 0x00F, 0x001, 0x005, 0x000, 0x002, 0x00F, 0x001, 0x000, 0x002, 0x006,
-    0x000, 0x03F, 0x009, 0x000, 0x000, 0x003, 0x003, 0x007, 0x000, 0x000, 0x000, 0x031, 0x00E,
-    0x001, 0x000, 0x000, 0x001, 0x000, 0x002, 0x017, 0x003, 0x026, 0x000, 0x027, 0x000, 0x000,
-    0x00C, 0x001, 0x006, 0x000, 0x003, 0x001, 0x000, 0x000, 0x002, 0x002, 0x000, 0x003, 0x000,
-    0x008, 0x000, 0x01B, 0x000, 0x000, 0x00B, 0x013, 0x002, 0x001, 0x000, 0x002, 0x008, 0x000,
-    0x001, 0x009, 0x000, 0x00D, 0x000, 0x004, 0x01B, 0x000, 0x000, 0x000, 0x003, 0x002, 0x000,
-    0x001, 0x008, 0x00B, 0x015, 0x006, 0x001, 0x00B, 0x000, 0x008, 0x00A, 0x000, 0x000, 0x02B,
-    0x000, 0x002, 0x000, 0x003, 0x005, 0x00B, 0x000, 0x00C, 0x000, 0x004, 0x004, 0x000, 0x000,
-    0x001, 0x000, 0x000, 0x000, 0x007, 0x00A, 0x008, 0x002, 0x000, 0x001, 0x006, 0x014, 0x000,
-    0x000, 0x003, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x003, 0x000, 0x000, 0x006, 0x003,
-    0x000, 0x003, 0x000, 0x002, 0x000, 0x000, 0x000, 0x006, 0x000, 0x000, 0x004, 0x001, 0x004,
-    0x000, 0x003, 0x001, 0x001, 0x004, 0x001, 0x000, 0x000, 0x003, 0x000, 0x000, 0x001, 0x002,
-    0x001, 0x003, 0x002, 0x002, 0x000, 0x004, 0x00A, 0x008, 0x01E, 0x000, 0x000, 0x000, 0x000,
-    0x001, 0x006, 0x004, 0x000, 0x000, 0x004, 0x000, 0x000, 0x002, 0x00F, 0x00B, 0x014, 0x000,
-    0x002, 0x001, 0x000, 0x000, 0x000, 0x004, 0x000, 0x004, 0x002, 0x000, 0x006, 0x00B, 0x000,
-    0x009, 0x018, 0x006, 0x006, 0x005, 0x001, 0x002, 0x000, 0x000, 0x000, 0x000, 0x006, 0x000,
-    0x000, 0x00E, 0x001, 0x001, 0x000, 0x003, 0x000, 0x016, 0x003, 0x015, 0x000, 0x000, 0x006,
-    0x006, 0x002, 0x000, 0x003, 0x001, 0x000, 0x00B, 0x005, 0x005, 0x001, 0x000, 0x000, 0x003,
-    0x000, 0x004, 0x000, 0x010, 0x000, 0x000, 0x000, 0x000, 0x001, 0x003, 0x000, 0x000, 0x002,
-    0x002, 0x000, 0x00B, 0x000, 0x001, 0x005, 0x002, 0x000, 0x000, 0x011, 0x00F, 0x000, 0x001,
-    0x00D, 0x00C, 0x001, 0x00B, 0x002, 0x010, 0x008, 0x001, 0x001, 0x004, 0x005, 0x011, 0x001,
-    0x00B, 0x010, 0x000, 0x001, 0x006, 0x000, 0x00C, 0x000, 0x00E, 0x00B, 0x001, 0x000, 0x003,
-    0x022, 0x004, 0x000, 0x001, 0x000, 0x007, 0x001, 0x004, 0x006, 0x001, 0x001, 0x000, 0x001,
-    0x007, 0x003, 0x004, 0x007, 0x006, 0x001, 0x010, 0x00D, 0x000, 0x000, 0x000, 0x007, 0x003,
-    0x000, 0x008, 0x001, 0x007, 0x003, 0x003, 0x000, 0x000, 0x010, 0x003, 0x002, 0x000, 0x000,
-    0x000, 0x000, 0x005, 0x001, 0x000, 0x002, 0x000, 0x003, 0x000, 0x001, 0x010, 0x001, 0x000,
-    0x015, 0x003, 0x007, 0x001, 0x00D, 0x005, 0x002, 0x015, 0x000, 0x001, 0x009, 0x000, 0x006,
-    0x000, 0x003, 0x001, 0x000, 0x000, 0x002, 0x000, 0x002, 0x000, 0x000, 0x00F, 0x000, 0x001,
-    0x015, 0x004, 0x002, 0x002, 0x001, 0x008, 0x000, 0x000, 0x000, 0x00C, 0x000, 0x004, 0x000,
-    0x005, 0x007, 0x00F, 0x001, 0x003, 0x006, 0x001, 0x000, 0x004, 0x000, 0x00C, 0x004, 0x012,
-    0x002, 0x002, 0x000, 0x001, 0x018, 0x004, 0x000, 0x000, 0x001, 0x00C, 0x000, 0x000, 0x00E,
-    0x001, 0x000, 0x007, 0x002, 0x000, 0x000, 0x001, 0x017, 0x002, 0x002, 0x000, 0x000, 0x004,
-    0x001, 0x000, 0x002, 0x006, 0x002, 0x003, 0x00A, 0x000, 0x005, 0x000, 0x003, 0x001, 0x002,
-    0x002, 0x000, 0x001, 0x005, 0x003, 0x000, 0x00D, 0x00C, 0x001, 0x000, 0x001, 0x004, 0x000,
-    0x002, 0x000, 0x001, 0x000, 0x000, 0x001, 0x005, 0x000, 0x000, 0x000, 0x000, 0x001, 0x01D,
-    0x003, 0x002, 0x00C, 0x000, 0x000, 0x003, 0x009, 0x000, 0x000, 0x005, 0x003, 0x000, 0x001,
-    0x002, 0x006, 0x001, 0x008, 0x001, 0x001, 0x00D, 0x004, 0x006, 0x008, 0x001, 0x00B, 0x007,
-    0x00A, 0x006, 0x002, 0x00F, 0x005, 0x000, 0x00B, 0x006, 0x001, 0x001, 0x001, 0x004, 0x009,
-    0x000, 0x001, 0x000, 0x003, 0x000, 0x009, 0x009, 0x004, 0x001, 0x001, 0x009, 0x006, 0x002,
-    0x008, 0x007, 0x003, 0x000, 0x008, 0x007, 0x000, 0x014, 0x001, 0x001, 0x013, 0x003, 0x004,
-    0x000, 0x000, 0x003, 0x001, 0x000, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x005, 0x00A, 0x000, 0x000, 0x000, 0x012, 0x000, 0x000, 0x000, 0x002, 0x000, 0x008, 0x000,
-    0x016, 0x011, 0x007, 0x003, 0x000, 0x009, 0x001, 0x002, 0x000, 0x000, 0x000, 0x000, 0x000,
-    0x000, 0x001, 0x000, 0x000, 0x009, 0x00C, 0x004, 0x000, 0x002, 0x000, 0x000, 0x002, 0x001,
-    0x007, 0x000, 0x000, 0x001, 0x000, 0x003, 0x000, 0x000, 0x000, 0x000, 0x009, 0x003, 0x002,
-    0x008, 0x002, 0x000, 0x001, 0x001, 0x00A, 0x013, 0x002, 0x003, 0x001, 0x003, 0x006, 0x000,
-    0x003, 0x001, 0x004, 0x002, 0x000, 0x000, 0x004, 0x004, 0x000, 0x000, 0x000, 0x00D, 0x002,
-    0x009, 0x002, 0x000, 0x007, 0x007, 0x001, 0x000, 0x002, 0x006, 0x002, 0x000, 0x001, 0x002,
-    0x003, 0x000, 0x000, 0x009, 0x003, 0x007, 0x001, 0x000, 0x000, 0x00F, 0x001, 0x00C, 0x000,
-    0x003, 0x000, 0x002, 0x000, 0x000, 0x009, 0x002, 0x002, 0x000, 0x001, 0x000, 0x006, 0x000,
-    0x002, 0x002, 0x003, 0x002, 0x001, 0x00F, 0x001, 0x008, 0x002, 0x002, 0x009, 0x009, 0x00B,
-    0x007, 0x002, 0x000, 0x000, 0x005, 0x00E, 0x001, 0x004, 0x007, 0x002, 0x001, 0x000, 0x003,
-    0x00A, 0x000, 0x000, 0x00E, 0x000, 0x009, 0x003, 0x003, 0x001, 0x000, 0x000, 0x000, 0x007,
-    0x000, 0x008, 0x00E, 0x000, 0x000, 0x000, 0x000, 0x002, 0x010, 0x002, 0x001, 0x002, 0x000,
-    0x009, 0x000, 0x000, 0x002, 0x006, 0x000, 0x001, 0x000, 0x002, 0x000, 0x00D, 0x003, 0x001,
-    0x00B, 0x001, 0x001, 0x000, 0x007, 0x000, 0x000, 0x003, 0x002, 0x004, 0x006, 0x004, 0x000,
-    0x001, 0x008, 0x001, 0x005, 0x005, 0x00B, 0x011, 0x004, 0x002, 0x000, 0x02A, 0x000, 0x001,
-    0x004, 0x008, 0x004, 0x000, 0x001, 0x001, 0x000, 0x000, 0x001, 0x007, 0x00B, 0x003, 0x000,
-    0x002, 0x000, 0x005, 0x004, 0x002, 0x000, 0x001, 0x00A, 0x009, 0x001, 0x002, 0x000, 0x006,
-    0x003, 0x001, 0x006, 0x003, 0x000, 0x001, 0x003, 0x000, 0x000, 0x005, 0x002, 0x006, 0x002,
-    0x001, 0x000, 0x000, 0x000, 0x000, 0x003, 0x001, 0x000, 0x004, 0x000, 0x007, 0x001, 0x000,
-    0x000, 0x002, 0x008, 0x000, 0x004, 0x001, 0x015, 0x000, 0x004, 0x000, 0x000, 0x005, 0x000,
-    0x009, 0x002, 0x008, 0x006, 0x001, 0x000, 0x001, 0x001, 0x002, 0x000, 0x001, 0x003, 0x000,
-    0x000, 0x003, 0x000, 0x003, 0x001, 0x000, 0x000, 0x000, 0x000, 0x001, 0x001, 0x001, 0x008,
-    0x000, 0x001, 0x001, 0x001, 0x009, 0x003, 0x002, 0x000, 0x000, 0x001, 0x00C, 0x007, 0x003,
-    0x002, 0x00A, 0x000, 0x005, 0x008, 0x00A, 0x006, 0x005, 0x006, 0x001, 0x000, 0x003, 0x000,
-    0x006, 0x003, 0x000, 0x002, 0x002, 0x004, 0x005, 0x003, 0x002, 0x001, 0x000, 0x001, 0x005,
-    0x001, 0x000, 0x003, 0x001, 0x007, 0x001, 0x001, 0x000, 0x000, 0x003, 0x003, 0x007, 0x001,
-    0x000, 0x001, 0x001, 0x003, 0x00A, 0x003, 0x00A, 0x000, 0x000, 0x000, 0x001, 0x003, 0x001,
-    0x000, 0x004, 0x000, 0x002, 0x003, 0x006, 0x000, 0x000, 0x005, 0x001, 0x000, 0x000, 0x003,
-    0x005, 0x003, 0x001, 0x001, 0x003, 0x000, 0x000, 0x000, 0x001, 0x001, 0x001, 0x001, 0x000,
-    0x000, 0x001, 0x000, 0x001, 0x003, 0x001, 0x003, 0x004, 0x001, 0x009, 0x002, 0x002, 0x002,
-    0x003, 0x006, 0x001, 0x000, 0x000, 0x001, 0x007, 0x000, 0x004, 0x000, 0x001, 0x000, 0x00B,
-    0x000, 0x002, 0x001, 0x004, 0x000, 0x007, 0x002, 0x004, 0x008, 0x005, 0x001, 0x003, 0x001,
-    0x000, 0x002, 0x000, 0x003, 0x000, 0x006, 0x003, 0x002, 0x000, 0x000, 0x008, 0x00D, 0x001,
-    0x001, 0x000, 0x007, 0x001, 0x005, 0x008, 0x001, 0x009, 0x003, 0x000, 0x000, 0x003, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x004, 0x000, 0x000, 0x004, 0x003, 0x001, 0x004,
-    0x000, 0x000, 0x000, 0x003, 0x003, 0x009, 0x003, 0x001, 0x000, 0x00A, 0x000, 0x001, 0x004,
-    0x000, 0x001, 0x000, 0x000, 0x00C, 0x002, 0x000, 0x000, 0x007, 0x005, 0x000, 0x005, 0x000,
-    0x000, 0x004, 0x000, 0x003, 0x000, 0x001, 0x006, 0x004, 0x004, 0x000, 0x002, 0x000, 0x003,
-    0x001, 0x000, 0x005, 0x000, 0x002, 0x004, 0x000, 0x001, 0x000, 0x012, 0x001, 0x000, 0x008,
-    0x003, 0x000, 0x002, 0x000, 0x005, 0x001, 0x001, 0x002, 0x001, 0x008, 0x003, 0x000, 0x006,
-    0x001, 0x006, 0x001, 0x001, 0x002, 0x001, 0x000, 0x000, 0x000, 0x001, 0x003, 0x001, 0x004,
-    0x000, 0x003, 0x008, 0x000, 0x005, 0x000, 0x000, 0x002, 0x000, 0x000, 0x001, 0x000, 0x000,
-    0x00E, 0x001, 0x000, 0x000, 0x001, 0x003, 0x005, 0x000, 0x000, 0x001, 0x001, 0x003, 0x002,
-    0x000, 0x002, 0x000, 0x007, 0x000, 0x000, 0x007, 0x001, 0x001, 0x000, 0x003, 0x000, 0x004,
-    0x001, 0x002, 0x000, 0x000, 0x002, 0x003, 0x003, 0x000, 0x011, 0x000, 0x001, 0x001, 0x002,
-    0x006, 0x003, 0x000, 0x002, 0x004, 0x002, 0x005, 0x000, 0x000, 0x000, 0x006, 0x000, 0x003,
-    0x001, 0x007, 0x002, 0x000, 0x000, 0x000, 0x008, 0x000, 0x000, 0x001, 0x002, 0x000, 0x003,
-    0x001, 0x001, 0x003, 0x000, 0x001, 0x001, 0x00E, 0x001, 0x000, 0x001, 0x008, 0x001, 0x001,
-    0x001, 0x005, 0x008, 0x002, 0x003, 0x001, 0x000, 0x001, 0x003, 0x000, 0x001, 0x000, 0x003,
-    0x001, 0x003, 0x000, 0x000, 0x000, 0x002, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x001,
-    0x001, 0x002, 0x000, 0x004, 0x002, 0x001, 0x000, 0x007, 0x000, 0x003, 0x001, 0x000, 0x000,
-    0x000, 0x008, 0x001, 0x001, 0x000, 0x003, 0x001, 0x000, 0x000, 0x001, 0x001, 0x000, 0x000,
-    0x001, 0x005, 0x000, 0x001, 0x003, 0x002, 0x003, 0x001, 0x000, 0x00D, 0x001, 0x000, 0x003,
-    0x002, 0x001, 0x004, 0x003, 0x001, 0x002, 0x002, 0x001, 0x002, 0x001, 0x003, 0x008, 0x000,
-    0x003, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x003, 0x002, 0x006, 0x002, 0x008, 0x000,
-    0x000, 0x000, 0x000, 0x003, 0x000, 0x001, 0x000, 0x001, 0x005, 0x002, 0x005, 0x000, 0x001,
-    0x000, 0x000, 0x000, 0x002, 0x000, 0x001, 0x006, 0x000, 0x001, 0x003, 0x000, 0x000, 0x002,
-    0x000, 0x000, 0x001, 0x003, 0x00A, 0x004, 0x009, 0x000, 0x002, 0x000, 0x003, 0x003, 0x001,
-    0x001, 0x00A, 0x000, 0x006, 0x004, 0x003, 0x003, 0x002, 0x001, 0x004, 0x002, 0x002, 0x003,
-    0x005, 0x003, 0x000, 0x002, 0x000, 0x001, 0x001, 0x000, 0x002, 0x002, 0x001, 0x000, 0x004,
-    0x002, 0x004, 0x000, 0x000, 0x000, 0x001, 0x007, 0x000, 0x000, 0x002, 0x003, 0x002, 0x003,
-    0x000, 0x002, 0x001, 0x002, 0x000, 0x000, 0x000, 0x000, 0x003, 0x000, 0x004, 0x003, 0x008,
-    0x008, 0x000, 0x001, 0x000, 0x000, 0x001, 0x000, 0x004, 0x000, 0x000, 0x001, 0x00C, 0x001,
-    0x003, 0x000, 0x005, 0x001, 0x00A, 0x004, 0x001, 0x003, 0x001, 0x000, 0x001, 0x001, 0x000,
-    0x003, 0x003, 0x003, 0x000, 0x000, 0x000, 0x007, 0x000, 0x005, 0x001, 0x000, 0x002, 0x000,
-    0x003, 0x000, 0x002, 0x002, 0x001, 0x001, 0x001, 0x001, 0x004, 0x001, 0x005, 0x001, 0x000,
-    0x001, 0x002, 0x001, 0x002, 0x002, 0x000, 0x000, 0x002, 0x001, 0x001, 0x003, 0x000, 0x000,
-    0x004, 0x000, 0x00E, 0x004, 0x001, 0x002, 0x003, 0x001, 0x000, 0x002, 0x003, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x001, 0x000, 0x001, 0x000, 0x000, 0x00A,
-    0x002, 0x000, 0x000, 0x000, 0x000, 0x012, 0x000, 0x000, 0x004, 0x003, 0x000, 0x003, 0x003,
-    0x001, 0x001, 0x000, 0x000, 0x006, 0x005, 0x000, 0x001, 0x003, 0x002, 0x000, 0x001, 0x006,
-    0x000, 0x000, 0x000, 0x001, 0x003, 0x002, 0x000, 0x002, 0x000, 0x000, 0x001, 0x000, 0x000,
-    0x000, 0x003, 0x000, 0x005, 0x001, 0x002, 0x000, 0x000, 0x004, 0x000, 0x006, 0x000, 0x000,
-    0x003, 0x004, 0x002, 0x000, 0x002, 0x002, 0x001, 0x008, 0x000, 0x001, 0x001, 0x001, 0x000,
-    0x000, 0x001, 0x003, 0x000, 0x001, 0x003, 0x001, 0x000, 0x002, 0x000, 0x001, 0x000, 0x003,
-    0x005, 0x000, 0x004, 0x001, 0x005, 0x000, 0x000, 0x001, 0x004, 0x002, 0x000, 0x000, 0x000,
-    0x000, 0x004, 0x000, 0x000, 0x000, 0x001, 0x000, 0x010, 0x000, 0x001, 0x001, 0x000, 0x000,
-    0x000, 0x001, 0x000, 0x001, 0x001, 0x006, 0x003, 0x005, 0x001, 0x000, 0x001, 0x001, 0x002,
-    0x00E, 0x005, 0x003, 0x001, 0x001, 0x001, 0x002, 0x000, 0x001, 0x000, 0x004, 0x005, 0x002,
-    0x003, 0x005, 0x003, 0x004, 0x000, 0x005, 0x001, 0x002, 0x001, 0x001, 0x002, 0x000, 0x005,
-    0x001, 0x001, 0x001, 0x000, 0x002, 0x000, 0x006, 0x000, 0x001, 0x000, 0x002, 0x003, 0x002,
-    0x003, 0x001, 0x000, 0x007, 0x001, 0x002, 0x003, 0x002, 0x001, 0x003, 0x000, 0x000, 0x000,
-    0x001, 0x001, 0x005, 0x001, 0x000, 0x002, 0x001, 0x001, 0x001, 0x000, 0x000, 0x006, 0x000,
-    0x001, 0x002, 0x001, 0x002, 0x001, 0x000, 0x000, 0x002, 0x001, 0x000, 0x002, 0x002, 0x001,
-    0x002, 0x001, 0x003, 0x000, 0x002, 0x000, 0x000, 0x002, 0x000, 0x000, 0x002, 0x001, 0x001,
-    0x005, 0x004, 0x004, 0x001, 0x003, 0x007, 0x001, 0x000, 0x000, 0x001, 0x002, 0x002, 0x003,
-    0x001, 0x004, 0x005, 0x001, 0x001, 0x004, 0x001, 0x000, 0x008, 0x002, 0x000, 0x000, 0x003,
-    0x002, 0x000, 0x001, 0x001, 0x001, 0x006, 0x002, 0x000, 0x004, 0x004, 0x001, 0x000, 0x004,
-    0x002, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x001, 0x000, 0x004, 0x001, 0x009, 0x001,
-    0x004, 0x000, 0x001, 0x000, 0x001, 0x005, 0x000, 0x000, 0x000, 0x005, 0x003, 0x002, 0x003,
-    0x004, 0x008, 0x002, 0x002, 0x000, 0x006, 0x001, 0x001, 0x002, 0x001, 0x000, 0x000, 0x002,
-    0x000, 0x002, 0x002, 0x000, 0x002, 0x000, 0x002, 0x003, 0x000, 0x004, 0x002, 0x001, 0x002,
-    0x003, 0x005, 0x001, 0x002, 0x001, 0x000, 0x000, 0x000, 0x000, 0x000, 0x002, 0x002, 0x00B,
-    0x000, 0x000, 0x000, 0x001, 0x006, 0x005, 0x000, 0x000, 0x000, 0x002, 0x002, 0x000, 0x003,
-    0x003, 0x002, 0x001, 0x000, 0x001, 0x000, 0x000, 0x001, 0x001, 0x000, 0x000, 0x001, 0x001,
-    0x004, 0x001, 0x000, 0x002, 0x002, 0x003, 0x003, 0x000, 0x000, 0x002, 0x004, 0x001, 0x002,
-    0x005, 0x001, 0x001, 0x000, 0x001, 0x001, 0x001, 0x000, 0x004, 0x001, 0x000, 0x002, 0x000,
-    0x001, 0x000, 0x003, 0x002, 0x002, 0x007, 0x003, 0x001, 0x001, 0x001, 0x002, 0x001, 0x001,
-    0x003, 0x002, 0x000, 0x001, 0x002, 0x005, 0x001, 0x002, 0x001, 0x000, 0x003, 0x001, 0x000,
-    0x003, 0x000, 0x000, 0x000, 0x003, 0x001, 0x000, 0x002, 0x000, 0x001, 0x000, 0x001, 0x000,
-    0x001, 0x00A, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000,
-    0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x003, 0x000, 0x000, 0x001, 0x005, 0x004, 0x000,
-    0x000, 0x000, 0x007, 0x000, 0x001, 0x000, 0x003, 0x004, 0x003, 0x002, 0x000, 0x000, 0x001,
-    0x000, 0x001, 0x001, 0x000, 0x000, 0x003, 0x001, 0x001, 0x000, 0x000, 0x000, 0x005, 0x001,
-    0x000, 0x001, 0x001, 0x000, 0x003, 0x008, 0x000, 0x000, 0x003, 0x001, 0x000, 0x001, 0x004,
-    0x001, 0x002, 0x001, 0x002, 0x002, 0x002, 0x000, 0x000, 0x000, 0x002, 0x000, 0x002, 0x000,
-    0x001, 0x001, 0x001, 0x002, 0x003, 0x001, 0x004, 0x001, 0x001, 0x000, 0x001, 0x000, 0x003,
-    0x000, 0x002, 0x002, 0x002, 0x002, 0x000, 0x002, 0x002, 0x001, 0x000, 0x000, 0x002, 0x003,
-    0x000, 0x001, 0x000, 0x000, 0x003, 0x001, 0x001, 0x002, 0x002, 0x001, 0x003, 0x000, 0x009,
-    0x001, 0x000, 0x001, 0x001, 0x002, 0x001, 0x002, 0x000, 0x001, 0x001, 0x000, 0x001, 0x001,
-    0x001, 0x001, 0x001, 0x000, 0x001, 0x000, 0x008, 0x001, 0x001, 0x000, 0x001, 0x001, 0x004,
-    0x000, 0x000, 0x003, 0x001, 0x001, 0x000, 0x001, 0x000, 0x002, 0x000, 0x000, 0x002, 0x001,
-    0x002, 0x000, 0x001, 0x001, 0x000,
-];
-pub(crate) const COMBINING_MARK_KV: &[u32] = &[
-    0x1D165, 0x01B71, 0x0093B, 0x00D57, 0x00328, 0x11CB1, 0x1CF11, 0x11A0A, 0x01B82, 0xE01DC,
-    0x01ABD, 0x02DEB, 0x11CAF, 0x1D172, 0x1CF3E, 0x114B8, 0x1CF40, 0x0A950, 0x114BA, 0x00748,
-    0x16F7F, 0x020F0, 0x0A981, 0x101FD, 0x00FB1, 0x0102F, 0x01CD6, 0x1DA08, 0x00FA2, 0x11A57,
-    0x1612D, 0x00A41, 0x006E3, 0x00898, 0x01BA4, 0x112E7, 0x16F70, 0x01BF3, 0x16F6B, 0x0106B,
-    0x0A675, 0x1DA5B, 0x10D6B, 0x11EF3, 0x1CF25, 0x02DF7, 0x11A97, 0x0A8EB, 0x1BC9E, 0x0FE2E,
-    0x1133E, 0x00334, 0x111B7, 0x16F5F, 0x0105E, 0xE0112, 0x00656, 0x11C98, 0x10D6A, 0x11726,
-    0x0A94B, 0x0FE2D, 0x1DA50, 0x00A4B, 0x119DD, 0x0032F, 0x00A3F, 0x00C02, 0x11835, 0xE0128,
-    0x11300, 0x01ACB, 0x1DA19, 0x0A802, 0x01DD5, 0x11C3A, 0x112E0, 0x0A8B7, 0x00EB7, 0x017DD,
-    0x01A7B, 0x02DE5, 0x00EB1, 0x1DA69, 0x00FA9, 0x0A8E6, 0x00C3F, 0x0A8EA, 0xE0156, 0x1DAAD,
-    0x0109B, 0xE017F, 0x11A90, 0x017BF, 0x02DF1, 0x01A66, 0x006D6, 0x007AC, 0xE01E9, 0x01934,
-    0x0A92A, 0x1DA04, 0xE01CE, 0x111BE, 0x10A01, 0x01DFD, 0xE0141, 0x11236, 0x00D3E, 0x0FE25,
-    0x00741, 0x1E947, 0xE0191, 0x00311, 0x16F82, 0x01A75, 0x02DEC, 0x00F3E, 0x020D7, 0x1DA48,
-    0x1D182, 0x00303, 0x01B37, 0x1DA9F, 0x11A8F, 0x01036, 0x00AC0, 0x01BA1, 0xE0120, 0x116B6,
-    0x110B7, 0x01DEC, 0x00351, 0x00B02, 0x16F61, 0x01A7C, 0x114B5, 0x16F80, 0x11182, 0x00CF3,
-    0x11CAA, 0xE0198, 0x00DD8, 0x0A9B7, 0x00ECA, 0x02DF8, 0x0A8C5, 0x0AA4C, 0x008DC, 0x01064,
-    0x01C29, 0x0093E, 0x009BC, 0x01CD1, 0x1145E, 0x1DA42, 0x1143D, 0x110B1, 0x1E08F, 0x11A04,
-    0x1CF26, 0x1CF13, 0x00ACC, 0x10F4D, 0xE0104, 0x00823, 0xE01D4, 0x005A6, 0x11442, 0x00AC7,
-    0x11C9A, 0x0AABE, 0x11369, 0x16F72, 0xE01C7, 0x10A0F, 0x01A76, 0x11A03, 0x0061A, 0x11044,
-    0x01733, 0x00318, 0x0A826, 0x1CF31, 0x11F41, 0x10F4A, 0x00315, 0x00F37, 0x017B6, 0x111CA,
-    0x1171F, 0x10D69, 0x01CD7, 0x00364, 0x10F48, 0x00C81, 0x01A5A, 0x1DA11, 0x01CF4, 0x01DEF,
-    0x11937, 0x11A53, 0x0103A, 0x1CF32, 0x01082, 0xE018C, 0x01AC5, 0x11CB6, 0x11635, 0xE010D,
-    0xE0164, 0x1DA33, 0x0180D, 0x01AB1, 0x11370, 0x11C3E, 0x11CAE, 0x0ABE7, 0x11C95, 0x112E6,
-    0x0033D, 0x0A8EE, 0x1DA0F, 0x01773, 0x0033C, 0x020D5, 0x0034A, 0x1DA34, 0x00819, 0x11362,
-    0x00301, 0x01DFB, 0x00488, 0xE0165, 0x017B8, 0xE015B, 0x16122, 0x01DD4, 0x00F94, 0x00F7F,
-    0x1DA58, 0x11A8B, 0x01DDA, 0xE017A, 0x01BE6, 0x1DA5E, 0x00E4B, 0x11720, 0x0A9B8, 0x10F82,
-    0x0A9B6, 0x00744, 0x00C63, 0x11231, 0x00327, 0x00E38, 0x01939, 0x11F37, 0x00F18, 0x00340,
-    0x116B3, 0x11002, 0x02DFF, 0xE0183, 0x1CF1D, 0x00FAD, 0x1DA2E, 0x115BF, 0x02DF0, 0x00337,
-    0x1CF2D, 0x00B03, 0x1143B, 0x11373, 0x113C9, 0x16F92, 0x005BB, 0x00CCC, 0x01AC0, 0x01DF1,
-    0xE01A4, 0x017CD, 0x13455, 0x11CA5, 0x007EF, 0x1DA28, 0x01073, 0x00F71, 0x11C9F, 0xE018F,
-    0x1E001, 0x01ABA, 0x01933, 0x110B0, 0x1E948, 0xE01BB, 0x10378, 0x01ACD, 0x1E8D0, 0x11038,
-    0x00BC7, 0x0093A, 0x01CE0, 0x00F77, 0x16F64, 0x02DEF, 0x1E2AE, 0xE0134, 0x01BEC, 0x11146,
-    0x1DA64, 0x00D02, 0x114B2, 0x0FE2B, 0x0A928, 0x00AC9, 0x020DE, 0x01BEE, 0xE013D, 0xE0114,
-    0x0A94D, 0x11A34, 0x1DA0D, 0xE01D7, 0x113B9, 0x0081F, 0x116B4, 0x0A8E4, 0x10AE6, 0x017B7,
-    0xE0103, 0x00940, 0x11636, 0x00C62, 0x119D6, 0x16FF1, 0x01DE1, 0x01A68, 0x0065B, 0x00316,
-    0xE0154, 0x0081C, 0x0A670, 0x1DA4B, 0x1E945, 0x1D17B, 0x01920, 0x16F5A, 0x0A80B, 0xE0148,
-    0x0A8F1, 0x1DA4D, 0x009BE, 0x017C6, 0x1CF0A, 0x01A5E, 0x112E5, 0x00BBF, 0xE01E8, 0x114BF,
-    0x01AC6, 0x00746, 0x1DA75, 0x1112B, 0x1E000, 0x00ECC, 0x00822, 0x1D1AA, 0x16F77, 0x11348,
-    0x00FAC, 0x017BA, 0x00AC1, 0x01DE3, 0x0059F, 0xE01A8, 0x01AC3, 0x00FAE, 0x111B3, 0x11728,
-    0x0AABF, 0xE012A, 0x116AC, 0x00F76, 0x119E0, 0xE0106, 0x0030B, 0x02DF9, 0x005B3, 0x00341,
-    0x1DA62, 0x01A60, 0x1E8D1, 0x01CF8, 0x1E5EF, 0x112E4, 0x1DA32, 0x1163E, 0x00F84, 0xE017C,
-    0x00611, 0x008FD, 0x01ABF, 0x1DA53, 0x00483, 0x1CF41, 0x0085A, 0x017C4, 0x1DA1D, 0xE01E7,
-    0x00326, 0x1DA10, 0xE01D8, 0x11C9E, 0x11832, 0x01DC4, 0x00366, 0x11D8C, 0x16AF2, 0x11C3F,
-    0x11A8A, 0x0ABEC, 0x11D47, 0x01DE0, 0x00597, 0xE014F, 0x006DF, 0x111BC, 0x0AA2F, 0x0ABEA,
-    0x01B42, 0x00D62, 0x01087, 0xE01D0, 0x1DA06, 0x115C0, 0x0089B, 0x11933, 0x017C2, 0x0A69F,
-    0x01926, 0x110B5, 0x017CA, 0x11073, 0x11102, 0x1D180, 0x01B6F, 0x0AAEB, 0x00ABE, 0x10EFD,
-    0x02DFB, 0x00AE3, 0x00C4D, 0x01930, 0x01ACC, 0x00ABC, 0x01032, 0x00DF3, 0xE01EF, 0x00A03,
-    0x1DA57, 0x0030F, 0x1DAA1, 0x008F9, 0x020E5, 0x1DA23, 0x10F83, 0x008F5, 0x00343, 0x005B2,
-    0x02D7F, 0x11932, 0x020E2, 0x11F39, 0x1E018, 0x00D00, 0x0031A, 0x017BE, 0x10D27, 0x01753,
-    0x020D3, 0x00FB5, 0x02DEE, 0x00D82, 0x0033F, 0x00734, 0x1CF35, 0x11235, 0x116AE, 0xE016E,
-    0x0036A, 0x16F65, 0xE01BD, 0x0AA43, 0x11D35, 0xE0195, 0x01DF8, 0x00B3E, 0x00F86, 0x113BD,
-    0xE018E, 0x11A8E, 0x0A8BA, 0xE016C, 0x01A71, 0x11F34, 0x01084, 0x01DC9, 0x1CF37, 0x1CF1A,
-    0x113BA, 0xE0122, 0x11C3C, 0x00304, 0x008E6, 0x11A35, 0x01CE4, 0x017B9, 0x0FE2C, 0x0FE0F,
-    0x1DA27, 0x11A51, 0x1DA1B, 0x16AF0, 0x11A07, 0x00DDB, 0x1DAA5, 0x10A02, 0x0FE0C, 0x01DCF,
-    0xE01DE, 0x006EC, 0x1DA14, 0x112E1, 0x0A927, 0x11A38, 0x007AB, 0x005B5, 0x1D244, 0x0A9BE,
-    0x1E002, 0x11831, 0x01886, 0xE0169, 0xE0184, 0x1DA4A, 0x10A3F, 0x11128, 0x00595, 0x008DF,
-    0x16B31, 0x113BC, 0x0064C, 0x00658, 0x01DC2, 0x1E020, 0x113CC, 0x02DE6, 0x006DB, 0x007A8,
-    0x00821, 0x11633, 0x0A8B4, 0x008CF, 0xE0102, 0x0A823, 0x017D3, 0x01AC4, 0x11836, 0xE0151,
-    0x005BD, 0xE0117, 0x01BA2, 0x1CF3C, 0x00CBC, 0x16F81, 0x1D18B, 0x017BD, 0x00346, 0x1DA5D,
-    0x11CA7, 0xE0171, 0x0AAC1, 0x00CBE, 0x0A953, 0x01C30, 0x00329, 0x0089F, 0x008FA, 0x11725,
-    0x1136B, 0x01CDC, 0x11070, 0x008F6, 0x00308, 0x01BEB, 0x11233, 0xE0136, 0x00F3F, 0x1CF09,
-    0xE0100, 0x01DF3, 0x01035, 0x0102D, 0x00314, 0x008E1, 0x01DCE, 0x00A02, 0xE0157, 0xE0193,
-    0x13451, 0x11D3A, 0x00CC4, 0x0034E, 0x00733, 0x11C2F, 0x16F62, 0x111BB, 0x01B72, 0x007AF,
-    0x0036B, 0x00731, 0x008D3, 0x13453, 0x16F60, 0x01CF9, 0xE012D, 0xE0197, 0x00CCA, 0x00616,
-    0x0FE01, 0x01BE7, 0xE0177, 0x10A0D, 0x01B6E, 0x01DCD, 0x1E004, 0x008D8, 0x11723, 0xE0168,
-    0x11130, 0x01C28, 0x11C3D, 0x0064F, 0x0AAEC, 0x1DA40, 0x11C31, 0x01DCB, 0x01923, 0x11D34,
-    0x008FF, 0xE01D5, 0x0034F, 0x16121, 0x01B44, 0x0A948, 0xE01DA, 0x1612F, 0x00650, 0x0AA35,
-    0x00305, 0x020E8, 0x01752, 0x00AC4, 0x0A827, 0x1172A, 0x005AF, 0x01DC1, 0x11F3E, 0x1D189,
-    0x1DA49, 0x11D45, 0x01C2E, 0x01037, 0xE01BE, 0xE01A3, 0x0A672, 0x0A8E3, 0x115B4, 0x11CAD,
-    0x01DD2, 0x10EFF, 0x0064E, 0x0082C, 0x1611E, 0x0FE29, 0x00323, 0x00899, 0x00CD6, 0x00489,
-    0x008CC, 0x01922, 0x00A82, 0x0ABE8, 0x01B01, 0x16F63, 0x0064D, 0x1DAAB, 0x017D2, 0x0FE26,
-    0x00D3C, 0xE010A, 0x119DF, 0x1D171, 0x0A881, 0x01A56, 0x114C2, 0xE0113, 0x1D186, 0x11CB4,
-    0x10377, 0x11A3C, 0x1E015, 0x00F9F, 0x0A8C1, 0x00B57, 0x16127, 0x0AA7C, 0x115BA, 0xE0127,
-    0x00332, 0x11145, 0xE0179, 0xE0135, 0x00C4C, 0x008CE, 0x01A7F, 0x0031C, 0x006E1, 0x1E8D6,
-    0xE0145, 0x00F93, 0x00362, 0x00596, 0x00347, 0x00317, 0x00670, 0xE0160, 0x00735, 0x10F4F,
-    0x111C9, 0x11041, 0x1DA0E, 0x01928, 0x0FE06, 0x005C2, 0x005C4, 0x113E2, 0x1CF0D, 0x1CF1C,
-    0x020DF, 0x00B4D, 0x0A67C, 0x00C41, 0xE0125, 0x11234, 0x0032C, 0x11D8E, 0x0106A, 0x00D3B,
-    0x115DD, 0x00946, 0x00AC2, 0x01BAD, 0xE0196, 0x01714, 0x1344D, 0x0A94F, 0x1CF01, 0x00599,
-    0x01ABB, 0x1DA29, 0x00FBA, 0x11437, 0x020EA, 0x00B3C, 0x10A39, 0x113C7, 0x1CF43, 0x005AB,
-    0x00EC8, 0x020E1, 0x008D0, 0x1D168, 0xE0176, 0xE0133, 0x0192A, 0x0082A, 0x1193D, 0x01772,
-    0x1E949, 0x00DD1, 0xE01E5, 0x0A980, 0x111CE, 0x01DC0, 0x1E8D3, 0x1DA02, 0xE01CC, 0x00FB0,
-    0x0094B, 0x0135F, 0xE01B3, 0x008D7, 0x00313, 0x16F5B, 0x00E4A, 0x00610, 0x114BB, 0x00CCB,
-    0x1171D, 0x1DA2C, 0x01C37, 0x0180C, 0x00FAB, 0x0065A, 0x115B2, 0x01A74, 0x113CE, 0x00CD5,
-    0x00BD7, 0x0105F, 0x00C43, 0x00947, 0x0FE2F, 0x0032E, 0x1E4ED, 0xE010C, 0x01DC7, 0x01A18,
-    0x1612A, 0x0A951, 0x006E7, 0x111B9, 0x00F90, 0x0032A, 0x02DEA, 0x16124, 0x0A8F0, 0x00FA1,
-    0xE01A9, 0x0036F, 0x00ECB, 0x0093C, 0x110B8, 0x00BBE, 0x11C99, 0x008E8, 0x0A8B5, 0x01B39,
-    0x0035C, 0x1DA4F, 0x0036E, 0x00740, 0x01A70, 0x01062, 0x0033A, 0x1E5EE, 0x1122D, 0x00FB9,
-    0x11D42, 0x017CC, 0x1D166, 0x11D91, 0x00CC8, 0x01A6B, 0x119D4, 0x112E9, 0x017C9, 0x1CF2C,
-    0xE0126, 0x00AFD, 0x1DA15, 0x1E010, 0x01B04, 0x0A8BE, 0x00BC0, 0x017B4, 0x01071, 0x11C94,
-    0x119DC, 0x11371, 0x005C5, 0x11363, 0x11A54, 0x01CD4, 0x008D4, 0x11301, 0x1E2EC, 0x01A5B,
-    0x11134, 0x005BF, 0x00B4C, 0x01A65, 0xE0180, 0x1182C, 0x16F73, 0x11C35, 0x00FA4, 0x01DCC,
-    0x115BD, 0xE016D, 0xE0159, 0xE010E, 0x00D40, 0x1CF19, 0xE015F, 0x00903, 0x00C48, 0x01734,
-    0x1DA43, 0x00825, 0x0FE22, 0x00ECD, 0x00333, 0x01B3A, 0x0089D, 0x018A9, 0x00E4D, 0x00312,
-    0x1172B, 0x119DE, 0x0034C, 0x1103C, 0x00829, 0x1CF42, 0x1DAA2, 0x009C7, 0x00957, 0x119D1,
-    0x11CA3, 0x1CF08, 0x00AC3, 0xE0166, 0x00D81, 0xE01D3, 0x1DA09, 0x00BCC, 0x02DED, 0x11A8D,
-    0x008E4, 0x00FA0, 0x1E135, 0x00F7E, 0x102E0, 0x00659, 0x00D63, 0x16F66, 0x008EA, 0x00A3E,
-    0x00732, 0xE01AB, 0x01072, 0x020ED, 0x00E35, 0x11639, 0x00F7B, 0x110C2, 0x01CDE, 0x1E028,
-    0x113E1, 0x113BE, 0x11368, 0x114B0, 0x1136A, 0x008E7, 0x1DA66, 0x01088, 0x1E4EC, 0x0A952,
-    0x0073C, 0x11374, 0x0073F, 0x1171E, 0x00B3F, 0xE01B5, 0x1182F, 0x11082, 0xE0146, 0x005B6,
-    0x1E2ED, 0x11D8D, 0x01063, 0x1DAA6, 0x01B3F, 0x115B1, 0x00A3C, 0x01A5C, 0x113D2, 0x1D1AC,
-    0x0A8EF, 0x0FE21, 0x115BB, 0x11830, 0x00FBB, 0x0ABED, 0x00C04, 0x020D4, 0x0A6F0, 0x0089E,
-    0x0059B, 0x16B32, 0xE018B, 0x00FAA, 0x0109C, 0x00827, 0x01DD9, 0x13440, 0x01925, 0x0031B,
-    0x01712, 0xE014A, 0x020D2, 0x0A677, 0x114C1, 0x1E003, 0x00CC1, 0x1112F, 0x00DCA, 0x1143F,
-    0x11C30, 0x00613, 0x0AAF5, 0x10F4C, 0x02DE9, 0x1E131, 0xE018A, 0x1037A, 0x01DFF, 0x00816,
-    0x16123, 0x00747, 0x00B47, 0x1136C, 0x111B8, 0x00D03, 0x112EA, 0x01038, 0xE01B9, 0x11133,
-    0x1CF23, 0x0AA4D, 0x11230, 0x00C83, 0x00743, 0xE0150, 0x11F36, 0x0193A, 0x017CE, 0x01C31,
-    0x01AB5, 0x11D94, 0x0A983, 0x00CCD, 0x00AFC, 0x11931, 0x1CF07, 0x1134B, 0x13452, 0x00CC3,
-    0x0089C, 0x00F87, 0x00AC8, 0xE016B, 0x0102C, 0x1DA00, 0x00486, 0x00EB6, 0x11D43, 0x01031,
-    0x114B9, 0x11040, 0x0A8FF, 0x11935, 0x1CF3D, 0x119D2, 0x10EAC, 0x11A08, 0x00F8E, 0x00DD0,
-    0x00730, 0x0A9E5, 0xE0194, 0x00DD4, 0x11940, 0x1CF04, 0x1344E, 0xE0190, 0x017C8, 0xE01CF,
-    0x00820, 0x009C2, 0x02DFE, 0x11080, 0x0A671, 0x1E009, 0x1DA61, 0x00C3C, 0x00944, 0x0034D,
-    0x00FB3, 0x119DA, 0x0A9BB, 0x008F2, 0x01DF6, 0x00A42, 0x116B0, 0x11729, 0x0302C, 0x01A58,
-    0x16F76, 0x1E00E, 0x01AB4, 0x01DE7, 0x020EC, 0x10A38, 0x00A51, 0xE01C5, 0x10F47, 0x01938,
-    0x00D44, 0x005A2, 0x1E01D, 0x01DCA, 0x007AD, 0x1DA59, 0x1163C, 0x16F7B, 0x01C34, 0x116B5,
-    0x00306, 0xE01CD, 0x02DFD, 0x1DAAE, 0x00E4C, 0x1CF1F, 0x00BCA, 0x1133F, 0x11938, 0x11344,
-    0x16125, 0x1E944, 0x01DDE, 0xE010B, 0xE011D, 0x10F4B, 0x00B48, 0x00DDD, 0x11727, 0x00592,
-    0x16B30, 0x005B7, 0x00355, 0x00D4B, 0x1D1AD, 0xE012B, 0x13447, 0xE0101, 0x01DF2, 0x02DFA,
-    0x01C2B, 0x01B40, 0x11357, 0x11100, 0x008ED, 0xE0109, 0x1DA03, 0x0FE28, 0x11722, 0x01CE6,
-    0x005B0, 0x00615, 0x1DAA8, 0x00342, 0x00BCB, 0x11042, 0x01CD8, 0x01A17, 0x01C2A, 0x00F79,
-    0x1112A, 0x11C3B, 0x01CE8, 0x1DA24, 0xE0189, 0xE01EE, 0x11D3D, 0x00FBC, 0x00367, 0x116B1,
-    0x11074, 0x0A66F, 0x0031F, 0x11237, 0x01DF9, 0x01DE5, 0x01ABE, 0x0074A, 0x00F75, 0x10376,
-    0x115B3, 0x0AA2C, 0x00DCF, 0xE013A, 0xE019F, 0x11C38, 0x1183A, 0x00A75, 0x00484, 0x119D7,
-    0x00D46, 0x008DB, 0x0032B, 0x0FB1E, 0x1123E, 0x110B4, 0x11C9D, 0x1CF46, 0x1D16D, 0x00AE2,
-    0x01058, 0x0106D, 0x1143C, 0x01DDF, 0x16120, 0xE015A, 0x00338, 0x01CDA, 0x00591, 0x00B56,
-    0x1D187, 0x00737, 0x00F9A, 0x00CC2, 0x01B6C, 0x01DD0, 0x00CC0, 0x00A83, 0x11D97, 0x006D8,
-    0x01B34, 0x00FA6, 0x116AD, 0x00DF2, 0x1163D, 0x0192B, 0x020E4, 0x10F84, 0xE0119, 0x008DD,
-    0x006EB, 0x01059, 0x16F75, 0x00983, 0x00963, 0x02CF1, 0x1E130, 0x00300, 0x113CD, 0x0A6F1,
-    0xE0143, 0x0FE0B, 0x02DF2, 0x006ED, 0x017C1, 0x01C2C, 0x005A7, 0x16F86, 0x00952, 0x01A62,
-    0x01A19, 0x16FE4, 0x01DEE, 0x0180F, 0x1DA65, 0x0109D, 0x03099, 0x11A91, 0x006E8, 0x01AB7,
-    0x01DD3, 0x1D16E, 0x007B0, 0xE0105, 0x00352, 0x0A9BF, 0x1E017, 0x00D41, 0x0059D, 0x01DF7,
-    0x0A8BC, 0x005C1, 0x0A8ED, 0x11101, 0x11438, 0x11EF5, 0x007A7, 0x1DA35, 0x11A59, 0x00307,
-    0x1E008, 0x10A05, 0xE01C8, 0x1CF14, 0x11444, 0x0033E, 0x008E9, 0x00ACB, 0x16F58, 0xE01C1,
-    0x16F6D, 0x00B62, 0x01A73, 0x01CE7, 0x16F57, 0x01C36, 0x01060, 0x11D93, 0x11C96, 0x0035E,
-    0x00F9C, 0x11A92, 0xE0181, 0x16AF4, 0x1DAA9, 0x00F7C, 0x1DA55, 0x1E01E, 0x01ACE, 0x11CA4,
-    0x0135D, 0x00357, 0x0094E, 0x020D0, 0x11343, 0xE01AD, 0x1D1AB, 0x00EB9, 0xE0172, 0x00593,
-    0x00D4A, 0x0AA31, 0xE01ED, 0x0089A, 0xE01A0, 0x11D96, 0x00948, 0x0A67A, 0x1E4EF, 0x01BEF,
-    0x00F8F, 0x0A824, 0xE017E, 0x1DA4E, 0x00B82, 0x00CC7, 0x020DB, 0x13448, 0x00A40, 0x0A94E,
-    0x11837, 0x10F49, 0x01083, 0xE0188, 0x1DA1F, 0x1D17C, 0x0A678, 0x00DDA, 0x006D7, 0x110B2,
-    0x00826, 0x0A82C, 0x01CDF, 0x0AA2D, 0x009C4, 0x008E5, 0xE011C, 0x00E4E, 0x0A8E0, 0x1612B,
-    0xE015C, 0x11F00, 0x01B02, 0x0A9BD, 0x11443, 0x1E026, 0x0A9B9, 0x0A94A, 0xE01D6, 0x01B73,
-    0x1DA63, 0x13454, 0x11A96, 0x1D167, 0x11001, 0x1DA51, 0x113C5, 0x11F3A, 0x1D17E, 0x11D3F,
-    0x00D01, 0x01A1A, 0x11439, 0x11A06, 0x01DF0, 0xE013B, 0x00F19, 0x00DD6, 0xE0167, 0x16F6F,
-    0x00F72, 0x16F79, 0x00F81, 0x00A71, 0x119D5, 0x1103D, 0x1DA41, 0x01DDB, 0x0093F, 0x0FE00,
-    0x008F7, 0x00B40, 0x00949, 0x0A9C0, 0x1103A, 0xE014E, 0x0A67B, 0xE0118, 0x01DEA, 0xE0107,
-    0x1193C, 0x115BC, 0x01BA3, 0x00E34, 0x11366, 0x1CF3A, 0xE01DB, 0x0A929, 0xE01B1, 0xE0163,
-    0x119E4, 0x00324, 0x01B6D, 0x017C0, 0x020DD, 0x01DD8, 0x0FE27, 0x11A93, 0x10D24, 0x114BD,
-    0x0302A, 0x1CF1B, 0x1344F, 0x0081B, 0x1DA2A, 0x00309, 0x1CF29, 0x01DE4, 0x0A8BB, 0x113BB,
-    0x00FC6, 0x11045, 0xE0147, 0x00FA8, 0x017CF, 0x00EBC, 0x00C55, 0x01A6A, 0x0A92C, 0x00941,
-    0x11046, 0x01DE8, 0xE019C, 0x10D6C, 0x11EF4, 0x020E9, 0x0059A, 0x00D4C, 0x0031D, 0x01C33,
-    0xE0140, 0x1107F, 0x00E39, 0x01CED, 0x1DA47, 0x005AD, 0xE01C9, 0x01AC8, 0x00901, 0x1D185,
-    0x1DA1A, 0x1D181, 0x01ACA, 0x11CA9, 0x10A0C, 0x11A3B, 0x00953, 0xE01E0, 0x00ABF, 0xE011F,
-    0x009E2, 0xE0111, 0x005A0, 0x11833, 0x1DA05, 0x115AF, 0x0302D, 0x113C2, 0xE012C, 0x0082D,
-    0x1143E, 0xE01D2, 0x00B41, 0x01A55, 0x00302, 0x113CF, 0x00FB4, 0x0AAB0, 0x16F87, 0x01DC6,
-    0x0AA32, 0xE0130, 0x020E7, 0x008DE, 0x007A9, 0x00739, 0x10F46, 0xE01AE, 0x114BC, 0x02CF0,
-    0x11A47, 0x01A67, 0x1D170, 0x01A61, 0x00DDE, 0x1E012, 0x0135E, 0x0065E, 0x00DD9, 0xE0199,
-    0xE013C, 0x1DA68, 0x11A05, 0x01929, 0x16F6C, 0x11F03, 0x16B35, 0x0A8C0, 0x005AA, 0x10AE5,
-    0x00B01, 0x16AF3, 0x0FE07, 0x00FAF, 0x1DA26, 0x10D26, 0x1E00C, 0x0081E, 0x1DA3F, 0x01CD0,
-    0x01BAC, 0xE0178, 0x01B36, 0x00C47, 0x0180B, 0x00654, 0x01DDC, 0x008EC, 0x1DA5F, 0x16F90,
-    0x01DFC, 0x0103E, 0x11F38, 0x16FF0, 0x01DD7, 0xE015E, 0x00B55, 0x00614, 0x0030A, 0x1163B,
-    0x11D95, 0x01074, 0xE0142, 0x00F99, 0xE01A6, 0x1163A, 0x1CF45, 0x1CF0F, 0xE0158, 0x0FE0E,
-    0x0A825, 0x0108B, 0x00E49, 0x020D9, 0x1E00A, 0x1CF16, 0x0AAEE, 0x1E01B, 0x16F78, 0x10F4E,
-    0xE019E, 0x16B34, 0x008EE, 0xE01C3, 0x00320, 0x11C33, 0x16F69, 0xE0132, 0x1103E, 0x0ABE3,
-    0x00945, 0x00902, 0x1DA5A, 0x11446, 0x00C40, 0x1DA30, 0x0073E, 0xE012F, 0x11C9B, 0x11C36,
-    0x007FD, 0x00360, 0x00E3A, 0x116AF, 0x01C32, 0x0A8E2, 0x005B1, 0x1122C, 0x0103B, 0xE013F,
-    0x00BC2, 0x11C34, 0x11081, 0x02DF4, 0x119DB, 0x11631, 0x01A6D, 0x16F55, 0x00B44, 0x16B36,
-    0x01DFE, 0x11A02, 0x1E8D4, 0x0AAEF, 0x00AFE, 0x020EB, 0x005A5, 0x1CF18, 0x00ACD, 0x11445,
-    0x115B5, 0x16F53, 0x005A1, 0x00F95, 0x0FE09, 0xE01E3, 0x111B6, 0x00EB8, 0x1CF10, 0x1DA3E,
-    0x1E00B, 0x0102E, 0x006EA, 0x11A95, 0x11435, 0x00D47, 0x00CE2, 0x00F74, 0x11043, 0xE0124,
-    0x113BF, 0x008D6, 0x11A52, 0x11A8C, 0xE01CA, 0x00FA3, 0x1E00F, 0x11EF6, 0x16F7A, 0x111BA,
-    0x1CF2B, 0x0A8E7, 0x1E00D, 0x1CF3F, 0x0ABE6, 0x005A3, 0x00A70, 0x01885, 0x0034B, 0x1E011,
-    0x00FB8, 0x01A6F, 0x01CD2, 0xE011A, 0x01030, 0x16F7E, 0x16F5D, 0x11D90, 0x00349, 0x01AB9,
-    0x1E02A, 0x007EE, 0x01B3D, 0x0106C, 0x11CA6, 0x0033B, 0x01039, 0x020E3, 0x11A55, 0x00736,
-    0x01B6B, 0x1344C, 0x007AA, 0x00BCD, 0x008CD, 0x11039, 0x01AB3, 0x1DAAA, 0x0030D, 0x01089,
-    0x0302B, 0x01A6C, 0x11131, 0x0A8E9, 0xE01EB, 0x1DA21, 0x1DA45, 0x00C4B, 0x02DF3, 0x1DAAF,
-    0x020D6, 0x0A94C, 0x00C03, 0x01A78, 0x00EB5, 0xE011B, 0x02DE7, 0xE0138, 0x11232, 0x16F56,
-    0x1CF0B, 0xE0144, 0x13449, 0x1DA0C, 0x01BED, 0x0A982, 0xE01A5, 0x1CF06, 0x16F85, 0x0A679,
-    0x008CB, 0x0A8BF, 0x0064B, 0x1DA3D, 0x1E8D5, 0x00E47, 0x01069, 0x008D2, 0x113B8, 0x00335,
-    0x01713, 0x01A5D, 0x00C82, 0x0A67D, 0x1CF33, 0x11CB0, 0xE0153, 0x00897, 0x16F8F, 0x11A5A,
-    0x11724, 0x1E016, 0x0103D, 0x01B3E, 0x01DC8, 0x16B33, 0x01937, 0x01A6E, 0x10A3A, 0x01BAA,
-    0x01B43, 0x0FE0A, 0x020D8, 0xE014C, 0x02DF6, 0x1CF15, 0x020EE, 0x00942, 0xE0162, 0x009C1,
-    0x00653, 0x0FE08, 0x1D17F, 0x017C5, 0x008CA, 0x1DA9B, 0x005BA, 0x00BC6, 0x00C42, 0x00738,
-    0x11632, 0x1DA18, 0x008F8, 0x005AE, 0x116B7, 0x1134C, 0x11834, 0x0085B, 0x005C7, 0x11943,
-    0x0A9B4, 0x1E029, 0x11A01, 0x020E0, 0x1103F, 0x00612, 0x01BA7, 0x00365, 0x0073B, 0x009D7,
-    0x0193B, 0x11838, 0x01067, 0x0FE04, 0x11D32, 0x01DD6, 0x1DA2B, 0x0FE24, 0x01A7A, 0xE016A,
-    0x0FE02, 0x16F6A, 0x1344B, 0x113CA, 0x11241, 0x110BA, 0x00C3E, 0x007AE, 0x0030C, 0xE0185,
-    0x01AC9, 0x01C26, 0x1DA6A, 0x11436, 0x00331, 0x1CF27, 0x11367, 0xE0139, 0x00859, 0x01927,
-    0x1CF02, 0x1DA9C, 0xE01B0, 0x111BF, 0x16128, 0x01DEB, 0x0AA30, 0xE0174, 0x1DAA4, 0x01ABC,
-    0x00CC6, 0x01B38, 0x1DA5C, 0x020DC, 0x00C4A, 0x1CF34, 0x11D8B, 0x16129, 0x00955, 0x0AAED,
-    0x10EAB, 0x017C7, 0x01BA8, 0x0AA2E, 0x1D16F, 0xE0116, 0x017BC, 0x0AAB3, 0xE01B7, 0x01BE9,
-    0x1E006, 0x1E4EE, 0x01B70, 0x00325, 0xE0186, 0x0A92D, 0x11930, 0x111B5, 0x01A72, 0x1DA44,
-    0xE01E6, 0x1DA1C, 0x005AC, 0x01B41, 0x10A03, 0x00363, 0x114C0, 0xE0123, 0x008E0, 0x01936,
-    0x00D4D, 0x00C56, 0x00DDC, 0x11A39, 0x1E2EF, 0x006DC, 0x017D0, 0x1D242, 0x00359, 0x0A8E1,
-    0x1CF05, 0x0094C, 0x01BF1, 0x008EF, 0x16AF1, 0x11634, 0xE0161, 0x1DA12, 0x020DA, 0x008D1,
-    0x0094A, 0x008FB, 0x01BA6, 0x00D48, 0xE0108, 0x1E946, 0x00319, 0x017B5, 0x00339, 0x01DE2,
-    0x11638, 0x0073A, 0x01057, 0x01CF7, 0x11173, 0x0309A, 0x1133B, 0x020EF, 0x112E2, 0x1E133,
-    0x1DA52, 0x005B8, 0x00E37, 0x1D18A, 0x16F67, 0x1133C, 0x00598, 0x11A37, 0x00EBA, 0x111CB,
-    0x0AAF6, 0x005B4, 0x02DF5, 0x11441, 0x114B7, 0x00353, 0x1163F, 0x008E3, 0x00651, 0x007F1,
-    0x113D0, 0x0032D, 0x008FE, 0x115BE, 0x0AA34, 0x02DE1, 0x01B00, 0x006E4, 0x01CDB, 0x1CF03,
-    0x01C25, 0x115B8, 0x11129, 0x00330, 0x00C01, 0x00943, 0x0A926, 0x1DA0A, 0x10D25, 0x008D9,
-    0x0A9BC, 0x00322, 0x11C9C, 0xE0110, 0x13450, 0x00A47, 0x11F40, 0x01DC3, 0x01B3C, 0x1CF0E,
-    0x01924, 0x0A676, 0x0036C, 0x007EC, 0x1D169, 0xE01E4, 0x00F7A, 0x00DD2, 0x1CF20, 0x11630,
-    0x11347, 0x112E3, 0x01A59, 0x11D41, 0x11A36, 0xE0192, 0x0035B, 0x0065D, 0x00619, 0x00954,
-    0xE0137, 0xE0149, 0x11F42, 0x00749, 0x01DF4, 0x1112D, 0x01CE1, 0x1CF3B, 0x1103B, 0x007F0,
-    0xE01C0, 0x11D33, 0x00AFB, 0xE0175, 0x0AA33, 0x1DA3C, 0x0ABE5, 0x0ABE4, 0x02DE3, 0x1134D,
-    0x009CC, 0x1DA9D, 0x01AC2, 0xE01A2, 0x11D44, 0xE0129, 0x11127, 0x115DC, 0x01B3B, 0x1CF36,
-    0x00F97, 0x01CD5, 0x11D31, 0x00EB4, 0x1DA22, 0xE01EC, 0x10EFE, 0x00B63, 0x111C0, 0x1E013,
-    0x11A56, 0x116B2, 0x0A947, 0x00BC8, 0x1DA16, 0x1DA6C, 0x008F0, 0x01BF2, 0x009BF, 0x11CA1,
-    0x01CE2, 0xE01B4, 0xE012E, 0x01C2D, 0xE019D, 0x00F39, 0xE01AF, 0x1D188, 0x00D42, 0x01DD1,
-    0x00BC1, 0x112DF, 0x0108A, 0x1182D, 0x1E014, 0xE01D1, 0x115B9, 0x16F4F, 0xE01C2, 0x11180,
-    0xE017D, 0x01A57, 0x1CF00, 0x11A3D, 0x01921, 0x113C0, 0x00F82, 0xE01CB, 0x01CDD, 0x1DA01,
-    0x0ABE9, 0x11303, 0x1E005, 0x11341, 0x00B4B, 0x11C39, 0x01AB2, 0x16F74, 0x114C3, 0x0A949,
-    0x00617, 0x1CF17, 0x008EB, 0x005B9, 0x00745, 0x11CAB, 0x1DA36, 0x006E2, 0x16F54, 0x00C00,
-    0x114BE, 0x01B81, 0x0102B, 0x1CF1E, 0x0A806, 0x0A880, 0x020E6, 0x01DF5, 0xE01D9, 0x0FE23,
-    0x00487, 0x00F73, 0x01CE5, 0x11D36, 0x0081D, 0x1CF28, 0x11D40, 0x020D1, 0x0AA36, 0x0A8E5,
-    0x110B6, 0x0A8C2, 0x11F5A, 0x11181, 0x00F35, 0x00D43, 0x0094D, 0x1193E, 0x1143A, 0xE0115,
-    0x017D1, 0x1CF38, 0x0082B, 0x119D3, 0x00F80, 0x16F52, 0x005A4, 0xE0121, 0x008F4, 0xE01B2,
-    0x00F83, 0x10EFC, 0x00ECE, 0x16F5E, 0x10A06, 0x11A98, 0x0A9BA, 0xE01B6, 0x1DA0B, 0x00F96,
-    0x16F68, 0x00361, 0x00900, 0x16F7D, 0x00A81, 0x1612C, 0x1CF44, 0x0108C, 0x1DA60, 0x01B03,
-    0x0A69E, 0x0094F, 0x11F01, 0x1CF24, 0x00951, 0x02DE4, 0x11A94, 0x11A58, 0x02DE8, 0xE01BF,
-    0x111BD, 0x00EC9, 0x017C3, 0x0AA2A, 0x01B35, 0x00817, 0x1112C, 0x006DA, 0x009E3, 0x11372,
-    0x00D83, 0x11CAC, 0x01BA9, 0x16F71, 0x1DAAC, 0x0AAB8, 0x00CE3, 0x00652, 0x11340, 0x16F5C,
-    0x11000, 0x00FA7, 0x007A6, 0x11640, 0x11637, 0x11A3E, 0x008F1, 0x009FE, 0x11CA2, 0x0A8B9,
-    0x01A79, 0x0A8BD, 0x01C2F, 0x01068, 0x01DE9, 0x0AA7D, 0x00A48, 0x01A77, 0x11132, 0x00345,
-    0x110B9, 0x01931, 0x10379, 0x0FE2A, 0x1DA6B, 0x01AC1, 0xE01BC, 0x00354, 0x01085, 0x11942,
-    0x11F35, 0x009C0, 0x00344, 0xE01EA, 0x1DA20, 0x0302F, 0x0031E, 0x00FA5, 0x1CF0C, 0xE01A1,
-    0xE01C6, 0x00350, 0x01CE3, 0x0103C, 0x02DFC, 0x11342, 0x01A63, 0xE0173, 0x1CF21, 0xE019B,
-    0x00A01, 0xE014D, 0x00DDF, 0xE019A, 0x01AC7, 0x1D243, 0xE01DF, 0x0FE0D, 0x11302, 0xE01E1,
-    0x1D17D, 0x1DA17, 0x111CC, 0x0035F, 0x00962, 0x11D8A, 0x113C8, 0x0A9B3, 0x00818, 0x00356,
-    0x00B43, 0x1DAA7, 0x11721, 0x0AAB7, 0x111CF, 0x00956, 0xE01C4, 0xE013E, 0x008DA, 0x00B42,
-    0x1CF12, 0x0FE03, 0x11A99, 0x01DFA, 0x01DC5, 0x11CB3, 0x1DA67, 0xE0155, 0xE0131, 0x16F51,
-    0x1182E, 0x1DAA3, 0x00657, 0x16F84, 0x00982, 0x114B3, 0x005BC, 0x00594, 0x008FC, 0x01B80,
-    0xE017B, 0x01BF0, 0x02CEF, 0x007F2, 0x00D3F, 0x009C8, 0x01BAB, 0x1CF39, 0x00F91, 0x00AFA,
-    0xE016F, 0x0109A, 0x16F7C, 0x005A9, 0x00FB6, 0x00A4D, 0x0A8C3, 0x008F3, 0x10F85, 0x1193B,
-    0x00A4C, 0x11CA0, 0x0A9B5, 0x1E01C, 0x0A8E8, 0x0108D, 0x1DA46, 0x006D9, 0xE0152, 0x00711,
-    0x01DE6, 0x01A64, 0x01AB0, 0x01CD9, 0x00F9B, 0x00F9D, 0x00E31, 0x110B3, 0xE011E, 0x10F50,
-    0x01932, 0x00742, 0x0108F, 0x0AA2B, 0x01BA5, 0x1BC9D, 0x00E36, 0x00310, 0x1E134, 0x0065F,
-    0x16F59, 0x0FE20, 0x1CF22, 0xE01A7, 0x0059C, 0x0035A, 0x1611F, 0x1E027, 0xE0182, 0x00321,
-    0x0302E, 0x1CF30, 0xE015D, 0x00FB7, 0x01056, 0x00E48, 0xE01AC, 0x114B1, 0x01AB8, 0x00F92,
-    0x1DA31, 0x16F6E, 0x11C92, 0x16126, 0x00368, 0x00C46, 0x00FB2, 0x11A33, 0x00655, 0x01A69,
-    0x11440, 0x02DE2, 0x00369, 0x1344A, 0x1DA2D, 0x1E024, 0x0FE05, 0x112E8, 0x0A8B8, 0x0A92B,
-    0x11839, 0x0059E, 0x116AB, 0x0AA29, 0x017BB, 0x01C35, 0x00336, 0x1DA25, 0x16F91, 0x00618,
-    0x00F78, 0x0035D, 0x1DA2F, 0x0073D, 0x01033, 0x111B4, 0x1612E, 0x01715, 0x1DA54, 0x11CB5,
-    0x1122F, 0x1DA13, 0xE01DD, 0x11C32, 0x1DA1E, 0x1DA56, 0x0AAB4, 0x00358, 0x11C97, 0x01DDD,
-    0x00981, 0x00F8D, 0xE0187, 0x008D5, 0x01A1B, 0x00EBB, 0x00485, 0x11934, 0x02DE0, 0x1112E,
-    0x01034, 0x11C93, 0x007ED, 0x0A674, 0x0A8B6, 0x00C44, 0x1CF2A, 0x115B0, 0x11A5B, 0x11D3C,
-    0xE014B, 0x00DD3, 0xE01AA, 0xE01E2, 0x0A8EC, 0xE0170, 0xE01B8, 0x1122E, 0x10A0E, 0xE01BA,
-    0x006E0, 0x00CBF, 0x005A8, 0xE018D, 0xE010F, 0x1DA4C, 0x007F3, 0x00F9E, 0x1E136, 0x1DA84,
-    0x1E8D2, 0x11F3F, 0x00348, 0x1E132, 0x009C3, 0x1E2EE, 0x0030E, 0x0065C, 0x0036D, 0x11CB2,
-    0x01BEA, 0x01935, 0x0AA7B, 0x01732, 0x11A09, 0x00AC5, 0x0A8C4, 0x01C24, 0x01AB6, 0x007EB,
-    0x017CB, 0x01DED, 0x1DA3B, 0x1E021, 0x00F7D, 0x1E01F, 0x01086, 0x009CD, 0x10D6D, 0x1DA07,
-    0x114B4, 0x01BE8, 0x16F83, 0x009CB, 0x01C27, 0x1DA9E, 0x114B6, 0x00AFF, 0x0AAB2, 0x1E94A,
-    0x1E023,
-];
-#[inline]
-pub fn is_public_assigned(c: char) -> bool {
-    match c {
-        '\u{0000}'..='\u{0377}'
-        | '\u{037A}'..='\u{037F}'
-        | '\u{0384}'..='\u{038A}'
-        | '\u{038C}'
-        | '\u{038E}'..='\u{03A1}'
-        | '\u{03A3}'..='\u{052F}'
-        | '\u{0531}'..='\u{0556}'
-        | '\u{0559}'..='\u{058A}'
-        | '\u{058D}'..='\u{058F}'
-        | '\u{0591}'..='\u{05C7}'
-        | '\u{05D0}'..='\u{05EA}'
-        | '\u{05EF}'..='\u{05F4}'
-        | '\u{0600}'..='\u{070D}'
-        | '\u{070F}'..='\u{074A}'
-        | '\u{074D}'..='\u{07B1}'
-        | '\u{07C0}'..='\u{07FA}'
-        | '\u{07FD}'..='\u{082D}'
-        | '\u{0830}'..='\u{083E}'
-        | '\u{0840}'..='\u{085B}'
-        | '\u{085E}'
-        | '\u{0860}'..='\u{086A}'
-        | '\u{0870}'..='\u{088E}'
-        | '\u{0890}'..='\u{0891}'
-        | '\u{0897}'..='\u{0983}'
-        | '\u{0985}'..='\u{098C}'
-        | '\u{098F}'..='\u{0990}'
-        | '\u{0993}'..='\u{09A8}'
-        | '\u{09AA}'..='\u{09B0}'
-        | '\u{09B2}'
-        | '\u{09B6}'..='\u{09B9}'
-        | '\u{09BC}'..='\u{09C4}'
-        | '\u{09C7}'..='\u{09C8}'
-        | '\u{09CB}'..='\u{09CE}'
-        | '\u{09D7}'
-        | '\u{09DC}'..='\u{09DD}'
-        | '\u{09DF}'..='\u{09E3}'
-        | '\u{09E6}'..='\u{09FE}'
-        | '\u{0A01}'..='\u{0A03}'
-        | '\u{0A05}'..='\u{0A0A}'
-        | '\u{0A0F}'..='\u{0A10}'
-        | '\u{0A13}'..='\u{0A28}'
-        | '\u{0A2A}'..='\u{0A30}'
-        | '\u{0A32}'..='\u{0A33}'
-        | '\u{0A35}'..='\u{0A36}'
-        | '\u{0A38}'..='\u{0A39}'
-        | '\u{0A3C}'
-        | '\u{0A3E}'..='\u{0A42}'
-        | '\u{0A47}'..='\u{0A48}'
-        | '\u{0A4B}'..='\u{0A4D}'
-        | '\u{0A51}'
-        | '\u{0A59}'..='\u{0A5C}'
-        | '\u{0A5E}'
-        | '\u{0A66}'..='\u{0A76}'
-        | '\u{0A81}'..='\u{0A83}'
-        | '\u{0A85}'..='\u{0A8D}'
-        | '\u{0A8F}'..='\u{0A91}'
-        | '\u{0A93}'..='\u{0AA8}'
-        | '\u{0AAA}'..='\u{0AB0}'
-        | '\u{0AB2}'..='\u{0AB3}'
-        | '\u{0AB5}'..='\u{0AB9}'
-        | '\u{0ABC}'..='\u{0AC5}'
-        | '\u{0AC7}'..='\u{0AC9}'
-        | '\u{0ACB}'..='\u{0ACD}'
-        | '\u{0AD0}'
-        | '\u{0AE0}'..='\u{0AE3}'
-        | '\u{0AE6}'..='\u{0AF1}'
-        | '\u{0AF9}'..='\u{0AFF}'
-        | '\u{0B01}'..='\u{0B03}'
-        | '\u{0B05}'..='\u{0B0C}'
-        | '\u{0B0F}'..='\u{0B10}'
-        | '\u{0B13}'..='\u{0B28}'
-        | '\u{0B2A}'..='\u{0B30}'
-        | '\u{0B32}'..='\u{0B33}'
-        | '\u{0B35}'..='\u{0B39}'
-        | '\u{0B3C}'..='\u{0B44}'
-        | '\u{0B47}'..='\u{0B48}'
-        | '\u{0B4B}'..='\u{0B4D}'
-        | '\u{0B55}'..='\u{0B57}'
-        | '\u{0B5C}'..='\u{0B5D}'
-        | '\u{0B5F}'..='\u{0B63}'
-        | '\u{0B66}'..='\u{0B77}'
-        | '\u{0B82}'..='\u{0B83}'
-        | '\u{0B85}'..='\u{0B8A}'
-        | '\u{0B8E}'..='\u{0B90}'
-        | '\u{0B92}'..='\u{0B95}'
-        | '\u{0B99}'..='\u{0B9A}'
-        | '\u{0B9C}'
-        | '\u{0B9E}'..='\u{0B9F}'
-        | '\u{0BA3}'..='\u{0BA4}'
-        | '\u{0BA8}'..='\u{0BAA}'
-        | '\u{0BAE}'..='\u{0BB9}'
-        | '\u{0BBE}'..='\u{0BC2}'
-        | '\u{0BC6}'..='\u{0BC8}'
-        | '\u{0BCA}'..='\u{0BCD}'
-        | '\u{0BD0}'
-        | '\u{0BD7}'
-        | '\u{0BE6}'..='\u{0BFA}'
-        | '\u{0C00}'..='\u{0C0C}'
-        | '\u{0C0E}'..='\u{0C10}'
-        | '\u{0C12}'..='\u{0C28}'
-        | '\u{0C2A}'..='\u{0C39}'
-        | '\u{0C3C}'..='\u{0C44}'
-        | '\u{0C46}'..='\u{0C48}'
-        | '\u{0C4A}'..='\u{0C4D}'
-        | '\u{0C55}'..='\u{0C56}'
-        | '\u{0C58}'..='\u{0C5A}'
-        | '\u{0C5D}'
-        | '\u{0C60}'..='\u{0C63}'
-        | '\u{0C66}'..='\u{0C6F}'
-        | '\u{0C77}'..='\u{0C8C}'
-        | '\u{0C8E}'..='\u{0C90}'
-        | '\u{0C92}'..='\u{0CA8}'
-        | '\u{0CAA}'..='\u{0CB3}'
-        | '\u{0CB5}'..='\u{0CB9}'
-        | '\u{0CBC}'..='\u{0CC4}'
-        | '\u{0CC6}'..='\u{0CC8}'
-        | '\u{0CCA}'..='\u{0CCD}'
-        | '\u{0CD5}'..='\u{0CD6}'
-        | '\u{0CDD}'..='\u{0CDE}'
-        | '\u{0CE0}'..='\u{0CE3}'
-        | '\u{0CE6}'..='\u{0CEF}'
-        | '\u{0CF1}'..='\u{0CF3}'
-        | '\u{0D00}'..='\u{0D0C}'
-        | '\u{0D0E}'..='\u{0D10}'
-        | '\u{0D12}'..='\u{0D44}'
-        | '\u{0D46}'..='\u{0D48}'
-        | '\u{0D4A}'..='\u{0D4F}'
-        | '\u{0D54}'..='\u{0D63}'
-        | '\u{0D66}'..='\u{0D7F}'
-        | '\u{0D81}'..='\u{0D83}'
-        | '\u{0D85}'..='\u{0D96}'
-        | '\u{0D9A}'..='\u{0DB1}'
-        | '\u{0DB3}'..='\u{0DBB}'
-        | '\u{0DBD}'
-        | '\u{0DC0}'..='\u{0DC6}'
-        | '\u{0DCA}'
-        | '\u{0DCF}'..='\u{0DD4}'
-        | '\u{0DD6}'
-        | '\u{0DD8}'..='\u{0DDF}'
-        | '\u{0DE6}'..='\u{0DEF}'
-        | '\u{0DF2}'..='\u{0DF4}'
-        | '\u{0E01}'..='\u{0E3A}'
-        | '\u{0E3F}'..='\u{0E5B}'
-        | '\u{0E81}'..='\u{0E82}'
-        | '\u{0E84}'
-        | '\u{0E86}'..='\u{0E8A}'
-        | '\u{0E8C}'..='\u{0EA3}'
-        | '\u{0EA5}'
-        | '\u{0EA7}'..='\u{0EBD}'
-        | '\u{0EC0}'..='\u{0EC4}'
-        | '\u{0EC6}'
-        | '\u{0EC8}'..='\u{0ECE}'
-        | '\u{0ED0}'..='\u{0ED9}'
-        | '\u{0EDC}'..='\u{0EDF}'
-        | '\u{0F00}'..='\u{0F47}'
-        | '\u{0F49}'..='\u{0F6C}'
-        | '\u{0F71}'..='\u{0F97}'
-        | '\u{0F99}'..='\u{0FBC}'
-        | '\u{0FBE}'..='\u{0FCC}'
-        | '\u{0FCE}'..='\u{0FDA}'
-        | '\u{1000}'..='\u{10C5}'
-        | '\u{10C7}'
-        | '\u{10CD}'
-        | '\u{10D0}'..='\u{1248}'
-        | '\u{124A}'..='\u{124D}'
-        | '\u{1250}'..='\u{1256}'
-        | '\u{1258}'
-        | '\u{125A}'..='\u{125D}'
-        | '\u{1260}'..='\u{1288}'
-        | '\u{128A}'..='\u{128D}'
-        | '\u{1290}'..='\u{12B0}'
-        | '\u{12B2}'..='\u{12B5}'
-        | '\u{12B8}'..='\u{12BE}'
-        | '\u{12C0}'
-        | '\u{12C2}'..='\u{12C5}'
-        | '\u{12C8}'..='\u{12D6}'
-        | '\u{12D8}'..='\u{1310}'
-        | '\u{1312}'..='\u{1315}'
-        | '\u{1318}'..='\u{135A}'
-        | '\u{135D}'..='\u{137C}'
-        | '\u{1380}'..='\u{1399}'
-        | '\u{13A0}'..='\u{13F5}'
-        | '\u{13F8}'..='\u{13FD}'
-        | '\u{1400}'..='\u{169C}'
-        | '\u{16A0}'..='\u{16F8}'
-        | '\u{1700}'..='\u{1715}'
-        | '\u{171F}'..='\u{1736}'
-        | '\u{1740}'..='\u{1753}'
-        | '\u{1760}'..='\u{176C}'
-        | '\u{176E}'..='\u{1770}'
-        | '\u{1772}'..='\u{1773}'
-        | '\u{1780}'..='\u{17DD}'
-        | '\u{17E0}'..='\u{17E9}'
-        | '\u{17F0}'..='\u{17F9}'
-        | '\u{1800}'..='\u{1819}'
-        | '\u{1820}'..='\u{1878}'
-        | '\u{1880}'..='\u{18AA}'
-        | '\u{18B0}'..='\u{18F5}'
-        | '\u{1900}'..='\u{191E}'
-        | '\u{1920}'..='\u{192B}'
-        | '\u{1930}'..='\u{193B}'
-        | '\u{1940}'
-        | '\u{1944}'..='\u{196D}'
-        | '\u{1970}'..='\u{1974}'
-        | '\u{1980}'..='\u{19AB}'
-        | '\u{19B0}'..='\u{19C9}'
-        | '\u{19D0}'..='\u{19DA}'
-        | '\u{19DE}'..='\u{1A1B}'
-        | '\u{1A1E}'..='\u{1A5E}'
-        | '\u{1A60}'..='\u{1A7C}'
-        | '\u{1A7F}'..='\u{1A89}'
-        | '\u{1A90}'..='\u{1A99}'
-        | '\u{1AA0}'..='\u{1AAD}'
-        | '\u{1AB0}'..='\u{1ACE}'
-        | '\u{1B00}'..='\u{1B4C}'
-        | '\u{1B4E}'..='\u{1BF3}'
-        | '\u{1BFC}'..='\u{1C37}'
-        | '\u{1C3B}'..='\u{1C49}'
-        | '\u{1C4D}'..='\u{1C8A}'
-        | '\u{1C90}'..='\u{1CBA}'
-        | '\u{1CBD}'..='\u{1CC7}'
-        | '\u{1CD0}'..='\u{1CFA}'
-        | '\u{1D00}'..='\u{1F15}'
-        | '\u{1F18}'..='\u{1F1D}'
-        | '\u{1F20}'..='\u{1F45}'
-        | '\u{1F48}'..='\u{1F4D}'
-        | '\u{1F50}'..='\u{1F57}'
-        | '\u{1F59}'
-        | '\u{1F5B}'
-        | '\u{1F5D}'
-        | '\u{1F5F}'..='\u{1F7D}'
-        | '\u{1F80}'..='\u{1FB4}'
-        | '\u{1FB6}'..='\u{1FC4}'
-        | '\u{1FC6}'..='\u{1FD3}'
-        | '\u{1FD6}'..='\u{1FDB}'
-        | '\u{1FDD}'..='\u{1FEF}'
-        | '\u{1FF2}'..='\u{1FF4}'
-        | '\u{1FF6}'..='\u{1FFE}'
-        | '\u{2000}'..='\u{2064}'
-        | '\u{2066}'..='\u{2071}'
-        | '\u{2074}'..='\u{208E}'
-        | '\u{2090}'..='\u{209C}'
-        | '\u{20A0}'..='\u{20C0}'
-        | '\u{20D0}'..='\u{20F0}'
-        | '\u{2100}'..='\u{218B}'
-        | '\u{2190}'..='\u{2429}'
-        | '\u{2440}'..='\u{244A}'
-        | '\u{2460}'..='\u{2B73}'
-        | '\u{2B76}'..='\u{2B95}'
-        | '\u{2B97}'..='\u{2CF3}'
-        | '\u{2CF9}'..='\u{2D25}'
-        | '\u{2D27}'
-        | '\u{2D2D}'
-        | '\u{2D30}'..='\u{2D67}'
-        | '\u{2D6F}'..='\u{2D70}'
-        | '\u{2D7F}'..='\u{2D96}'
-        | '\u{2DA0}'..='\u{2DA6}'
-        | '\u{2DA8}'..='\u{2DAE}'
-        | '\u{2DB0}'..='\u{2DB6}'
-        | '\u{2DB8}'..='\u{2DBE}'
-        | '\u{2DC0}'..='\u{2DC6}'
-        | '\u{2DC8}'..='\u{2DCE}'
-        | '\u{2DD0}'..='\u{2DD6}'
-        | '\u{2DD8}'..='\u{2DDE}'
-        | '\u{2DE0}'..='\u{2E5D}'
-        | '\u{2E80}'..='\u{2E99}'
-        | '\u{2E9B}'..='\u{2EF3}'
-        | '\u{2F00}'..='\u{2FD5}'
-        | '\u{2FF0}'..='\u{303F}'
-        | '\u{3041}'..='\u{3096}'
-        | '\u{3099}'..='\u{30FF}'
-        | '\u{3105}'..='\u{312F}'
-        | '\u{3131}'..='\u{318E}'
-        | '\u{3190}'..='\u{31E5}'
-        | '\u{31EF}'..='\u{321E}'
-        | '\u{3220}'..='\u{A48C}'
-        | '\u{A490}'..='\u{A4C6}'
-        | '\u{A4D0}'..='\u{A62B}'
-        | '\u{A640}'..='\u{A6F7}'
-        | '\u{A700}'..='\u{A7CD}'
-        | '\u{A7D0}'..='\u{A7D1}'
-        | '\u{A7D3}'
-        | '\u{A7D5}'..='\u{A7DC}'
-        | '\u{A7F2}'..='\u{A82C}'
-        | '\u{A830}'..='\u{A839}'
-        | '\u{A840}'..='\u{A877}'
-        | '\u{A880}'..='\u{A8C5}'
-        | '\u{A8CE}'..='\u{A8D9}'
-        | '\u{A8E0}'..='\u{A953}'
-        | '\u{A95F}'..='\u{A97C}'
-        | '\u{A980}'..='\u{A9CD}'
-        | '\u{A9CF}'..='\u{A9D9}'
-        | '\u{A9DE}'..='\u{A9FE}'
-        | '\u{AA00}'..='\u{AA36}'
-        | '\u{AA40}'..='\u{AA4D}'
-        | '\u{AA50}'..='\u{AA59}'
-        | '\u{AA5C}'..='\u{AAC2}'
-        | '\u{AADB}'..='\u{AAF6}'
-        | '\u{AB01}'..='\u{AB06}'
-        | '\u{AB09}'..='\u{AB0E}'
-        | '\u{AB11}'..='\u{AB16}'
-        | '\u{AB20}'..='\u{AB26}'
-        | '\u{AB28}'..='\u{AB2E}'
-        | '\u{AB30}'..='\u{AB6B}'
-        | '\u{AB70}'..='\u{ABED}'
-        | '\u{ABF0}'..='\u{ABF9}'
-        | '\u{AC00}'..='\u{D7A3}'
-        | '\u{D7B0}'..='\u{D7C6}'
-        | '\u{D7CB}'..='\u{D7FB}'
-        | '\u{F900}'..='\u{FA6D}'
-        | '\u{FA70}'..='\u{FAD9}'
-        | '\u{FB00}'..='\u{FB06}'
-        | '\u{FB13}'..='\u{FB17}'
-        | '\u{FB1D}'..='\u{FB36}'
-        | '\u{FB38}'..='\u{FB3C}'
-        | '\u{FB3E}'
-        | '\u{FB40}'..='\u{FB41}'
-        | '\u{FB43}'..='\u{FB44}'
-        | '\u{FB46}'..='\u{FBC2}'
-        | '\u{FBD3}'..='\u{FD8F}'
-        | '\u{FD92}'..='\u{FDC7}'
-        | '\u{FDCF}'
-        | '\u{FDF0}'..='\u{FE19}'
-        | '\u{FE20}'..='\u{FE52}'
-        | '\u{FE54}'..='\u{FE66}'
-        | '\u{FE68}'..='\u{FE6B}'
-        | '\u{FE70}'..='\u{FE74}'
-        | '\u{FE76}'..='\u{FEFC}'
-        | '\u{FEFF}'
-        | '\u{FF01}'..='\u{FFBE}'
-        | '\u{FFC2}'..='\u{FFC7}'
-        | '\u{FFCA}'..='\u{FFCF}'
-        | '\u{FFD2}'..='\u{FFD7}'
-        | '\u{FFDA}'..='\u{FFDC}'
-        | '\u{FFE0}'..='\u{FFE6}'
-        | '\u{FFE8}'..='\u{FFEE}'
-        | '\u{FFF9}'..='\u{FFFD}'
-        | '\u{10000}'..='\u{1000B}'
-        | '\u{1000D}'..='\u{10026}'
-        | '\u{10028}'..='\u{1003A}'
-        | '\u{1003C}'..='\u{1003D}'
-        | '\u{1003F}'..='\u{1004D}'
-        | '\u{10050}'..='\u{1005D}'
-        | '\u{10080}'..='\u{100FA}'
-        | '\u{10100}'..='\u{10102}'
-        | '\u{10107}'..='\u{10133}'
-        | '\u{10137}'..='\u{1018E}'
-        | '\u{10190}'..='\u{1019C}'
-        | '\u{101A0}'
-        | '\u{101D0}'..='\u{101FD}'
-        | '\u{10280}'..='\u{1029C}'
-        | '\u{102A0}'..='\u{102D0}'
-        | '\u{102E0}'..='\u{102FB}'
-        | '\u{10300}'..='\u{10323}'
-        | '\u{1032D}'..='\u{1034A}'
-        | '\u{10350}'..='\u{1037A}'
-        | '\u{10380}'..='\u{1039D}'
-        | '\u{1039F}'..='\u{103C3}'
-        | '\u{103C8}'..='\u{103D5}'
-        | '\u{10400}'..='\u{1049D}'
-        | '\u{104A0}'..='\u{104A9}'
-        | '\u{104B0}'..='\u{104D3}'
-        | '\u{104D8}'..='\u{104FB}'
-        | '\u{10500}'..='\u{10527}'
-        | '\u{10530}'..='\u{10563}'
-        | '\u{1056F}'..='\u{1057A}'
-        | '\u{1057C}'..='\u{1058A}'
-        | '\u{1058C}'..='\u{10592}'
-        | '\u{10594}'..='\u{10595}'
-        | '\u{10597}'..='\u{105A1}'
-        | '\u{105A3}'..='\u{105B1}'
-        | '\u{105B3}'..='\u{105B9}'
-        | '\u{105BB}'..='\u{105BC}'
-        | '\u{105C0}'..='\u{105F3}'
-        | '\u{10600}'..='\u{10736}'
-        | '\u{10740}'..='\u{10755}'
-        | '\u{10760}'..='\u{10767}'
-        | '\u{10780}'..='\u{10785}'
-        | '\u{10787}'..='\u{107B0}'
-        | '\u{107B2}'..='\u{107BA}'
-        | '\u{10800}'..='\u{10805}'
-        | '\u{10808}'
-        | '\u{1080A}'..='\u{10835}'
-        | '\u{10837}'..='\u{10838}'
-        | '\u{1083C}'
-        | '\u{1083F}'..='\u{10855}'
-        | '\u{10857}'..='\u{1089E}'
-        | '\u{108A7}'..='\u{108AF}'
-        | '\u{108E0}'..='\u{108F2}'
-        | '\u{108F4}'..='\u{108F5}'
-        | '\u{108FB}'..='\u{1091B}'
-        | '\u{1091F}'..='\u{10939}'
-        | '\u{1093F}'
-        | '\u{10980}'..='\u{109B7}'
-        | '\u{109BC}'..='\u{109CF}'
-        | '\u{109D2}'..='\u{10A03}'
-        | '\u{10A05}'..='\u{10A06}'
-        | '\u{10A0C}'..='\u{10A13}'
-        | '\u{10A15}'..='\u{10A17}'
-        | '\u{10A19}'..='\u{10A35}'
-        | '\u{10A38}'..='\u{10A3A}'
-        | '\u{10A3F}'..='\u{10A48}'
-        | '\u{10A50}'..='\u{10A58}'
-        | '\u{10A60}'..='\u{10A9F}'
-        | '\u{10AC0}'..='\u{10AE6}'
-        | '\u{10AEB}'..='\u{10AF6}'
-        | '\u{10B00}'..='\u{10B35}'
-        | '\u{10B39}'..='\u{10B55}'
-        | '\u{10B58}'..='\u{10B72}'
-        | '\u{10B78}'..='\u{10B91}'
-        | '\u{10B99}'..='\u{10B9C}'
-        | '\u{10BA9}'..='\u{10BAF}'
-        | '\u{10C00}'..='\u{10C48}'
-        | '\u{10C80}'..='\u{10CB2}'
-        | '\u{10CC0}'..='\u{10CF2}'
-        | '\u{10CFA}'..='\u{10D27}'
-        | '\u{10D30}'..='\u{10D39}'
-        | '\u{10D40}'..='\u{10D65}'
-        | '\u{10D69}'..='\u{10D85}'
-        | '\u{10D8E}'..='\u{10D8F}'
-        | '\u{10E60}'..='\u{10E7E}'
-        | '\u{10E80}'..='\u{10EA9}'
-        | '\u{10EAB}'..='\u{10EAD}'
-        | '\u{10EB0}'..='\u{10EB1}'
-        | '\u{10EC2}'..='\u{10EC4}'
-        | '\u{10EFC}'..='\u{10F27}'
-        | '\u{10F30}'..='\u{10F59}'
-        | '\u{10F70}'..='\u{10F89}'
-        | '\u{10FB0}'..='\u{10FCB}'
-        | '\u{10FE0}'..='\u{10FF6}'
-        | '\u{11000}'..='\u{1104D}'
-        | '\u{11052}'..='\u{11075}'
-        | '\u{1107F}'..='\u{110C2}'
-        | '\u{110CD}'
-        | '\u{110D0}'..='\u{110E8}'
-        | '\u{110F0}'..='\u{110F9}'
-        | '\u{11100}'..='\u{11134}'
-        | '\u{11136}'..='\u{11147}'
-        | '\u{11150}'..='\u{11176}'
-        | '\u{11180}'..='\u{111DF}'
-        | '\u{111E1}'..='\u{111F4}'
-        | '\u{11200}'..='\u{11211}'
-        | '\u{11213}'..='\u{11241}'
-        | '\u{11280}'..='\u{11286}'
-        | '\u{11288}'
-        | '\u{1128A}'..='\u{1128D}'
-        | '\u{1128F}'..='\u{1129D}'
-        | '\u{1129F}'..='\u{112A9}'
-        | '\u{112B0}'..='\u{112EA}'
-        | '\u{112F0}'..='\u{112F9}'
-        | '\u{11300}'..='\u{11303}'
-        | '\u{11305}'..='\u{1130C}'
-        | '\u{1130F}'..='\u{11310}'
-        | '\u{11313}'..='\u{11328}'
-        | '\u{1132A}'..='\u{11330}'
-        | '\u{11332}'..='\u{11333}'
-        | '\u{11335}'..='\u{11339}'
-        | '\u{1133B}'..='\u{11344}'
-        | '\u{11347}'..='\u{11348}'
-        | '\u{1134B}'..='\u{1134D}'
-        | '\u{11350}'
-        | '\u{11357}'
-        | '\u{1135D}'..='\u{11363}'
-        | '\u{11366}'..='\u{1136C}'
-        | '\u{11370}'..='\u{11374}'
-        | '\u{11380}'..='\u{11389}'
-        | '\u{1138B}'
-        | '\u{1138E}'
-        | '\u{11390}'..='\u{113B5}'
-        | '\u{113B7}'..='\u{113C0}'
-        | '\u{113C2}'
-        | '\u{113C5}'
-        | '\u{113C7}'..='\u{113CA}'
-        | '\u{113CC}'..='\u{113D5}'
-        | '\u{113D7}'..='\u{113D8}'
-        | '\u{113E1}'..='\u{113E2}'
-        | '\u{11400}'..='\u{1145B}'
-        | '\u{1145D}'..='\u{11461}'
-        | '\u{11480}'..='\u{114C7}'
-        | '\u{114D0}'..='\u{114D9}'
-        | '\u{11580}'..='\u{115B5}'
-        | '\u{115B8}'..='\u{115DD}'
-        | '\u{11600}'..='\u{11644}'
-        | '\u{11650}'..='\u{11659}'
-        | '\u{11660}'..='\u{1166C}'
-        | '\u{11680}'..='\u{116B9}'
-        | '\u{116C0}'..='\u{116C9}'
-        | '\u{116D0}'..='\u{116E3}'
-        | '\u{11700}'..='\u{1171A}'
-        | '\u{1171D}'..='\u{1172B}'
-        | '\u{11730}'..='\u{11746}'
-        | '\u{11800}'..='\u{1183B}'
-        | '\u{118A0}'..='\u{118F2}'
-        | '\u{118FF}'..='\u{11906}'
-        | '\u{11909}'
-        | '\u{1190C}'..='\u{11913}'
-        | '\u{11915}'..='\u{11916}'
-        | '\u{11918}'..='\u{11935}'
-        | '\u{11937}'..='\u{11938}'
-        | '\u{1193B}'..='\u{11946}'
-        | '\u{11950}'..='\u{11959}'
-        | '\u{119A0}'..='\u{119A7}'
-        | '\u{119AA}'..='\u{119D7}'
-        | '\u{119DA}'..='\u{119E4}'
-        | '\u{11A00}'..='\u{11A47}'
-        | '\u{11A50}'..='\u{11AA2}'
-        | '\u{11AB0}'..='\u{11AF8}'
-        | '\u{11B00}'..='\u{11B09}'
-        | '\u{11BC0}'..='\u{11BE1}'
-        | '\u{11BF0}'..='\u{11BF9}'
-        | '\u{11C00}'..='\u{11C08}'
-        | '\u{11C0A}'..='\u{11C36}'
-        | '\u{11C38}'..='\u{11C45}'
-        | '\u{11C50}'..='\u{11C6C}'
-        | '\u{11C70}'..='\u{11C8F}'
-        | '\u{11C92}'..='\u{11CA7}'
-        | '\u{11CA9}'..='\u{11CB6}'
-        | '\u{11D00}'..='\u{11D06}'
-        | '\u{11D08}'..='\u{11D09}'
-        | '\u{11D0B}'..='\u{11D36}'
-        | '\u{11D3A}'
-        | '\u{11D3C}'..='\u{11D3D}'
-        | '\u{11D3F}'..='\u{11D47}'
-        | '\u{11D50}'..='\u{11D59}'
-        | '\u{11D60}'..='\u{11D65}'
-        | '\u{11D67}'..='\u{11D68}'
-        | '\u{11D6A}'..='\u{11D8E}'
-        | '\u{11D90}'..='\u{11D91}'
-        | '\u{11D93}'..='\u{11D98}'
-        | '\u{11DA0}'..='\u{11DA9}'
-        | '\u{11EE0}'..='\u{11EF8}'
-        | '\u{11F00}'..='\u{11F10}'
-        | '\u{11F12}'..='\u{11F3A}'
-        | '\u{11F3E}'..='\u{11F5A}'
-        | '\u{11FB0}'
-        | '\u{11FC0}'..='\u{11FF1}'
-        | '\u{11FFF}'..='\u{12399}'
-        | '\u{12400}'..='\u{1246E}'
-        | '\u{12470}'..='\u{12474}'
-        | '\u{12480}'..='\u{12543}'
-        | '\u{12F90}'..='\u{12FF2}'
-        | '\u{13000}'..='\u{13455}'
-        | '\u{13460}'..='\u{143FA}'
-        | '\u{14400}'..='\u{14646}'
-        | '\u{16100}'..='\u{16139}'
-        | '\u{16800}'..='\u{16A38}'
-        | '\u{16A40}'..='\u{16A5E}'
-        | '\u{16A60}'..='\u{16A69}'
-        | '\u{16A6E}'..='\u{16ABE}'
-        | '\u{16AC0}'..='\u{16AC9}'
-        | '\u{16AD0}'..='\u{16AED}'
-        | '\u{16AF0}'..='\u{16AF5}'
-        | '\u{16B00}'..='\u{16B45}'
-        | '\u{16B50}'..='\u{16B59}'
-        | '\u{16B5B}'..='\u{16B61}'
-        | '\u{16B63}'..='\u{16B77}'
-        | '\u{16B7D}'..='\u{16B8F}'
-        | '\u{16D40}'..='\u{16D79}'
-        | '\u{16E40}'..='\u{16E9A}'
-        | '\u{16F00}'..='\u{16F4A}'
-        | '\u{16F4F}'..='\u{16F87}'
-        | '\u{16F8F}'..='\u{16F9F}'
-        | '\u{16FE0}'..='\u{16FE4}'
-        | '\u{16FF0}'..='\u{16FF1}'
-        | '\u{17000}'..='\u{187F7}'
-        | '\u{18800}'..='\u{18CD5}'
-        | '\u{18CFF}'..='\u{18D08}'
-        | '\u{1AFF0}'..='\u{1AFF3}'
-        | '\u{1AFF5}'..='\u{1AFFB}'
-        | '\u{1AFFD}'..='\u{1AFFE}'
-        | '\u{1B000}'..='\u{1B122}'
-        | '\u{1B132}'
-        | '\u{1B150}'..='\u{1B152}'
-        | '\u{1B155}'
-        | '\u{1B164}'..='\u{1B167}'
-        | '\u{1B170}'..='\u{1B2FB}'
-        | '\u{1BC00}'..='\u{1BC6A}'
-        | '\u{1BC70}'..='\u{1BC7C}'
-        | '\u{1BC80}'..='\u{1BC88}'
-        | '\u{1BC90}'..='\u{1BC99}'
-        | '\u{1BC9C}'..='\u{1BCA3}'
-        | '\u{1CC00}'..='\u{1CCF9}'
-        | '\u{1CD00}'..='\u{1CEB3}'
-        | '\u{1CF00}'..='\u{1CF2D}'
-        | '\u{1CF30}'..='\u{1CF46}'
-        | '\u{1CF50}'..='\u{1CFC3}'
-        | '\u{1D000}'..='\u{1D0F5}'
-        | '\u{1D100}'..='\u{1D126}'
-        | '\u{1D129}'..='\u{1D1EA}'
-        | '\u{1D200}'..='\u{1D245}'
-        | '\u{1D2C0}'..='\u{1D2D3}'
-        | '\u{1D2E0}'..='\u{1D2F3}'
-        | '\u{1D300}'..='\u{1D356}'
-        | '\u{1D360}'..='\u{1D378}'
-        | '\u{1D400}'..='\u{1D454}'
-        | '\u{1D456}'..='\u{1D49C}'
-        | '\u{1D49E}'..='\u{1D49F}'
-        | '\u{1D4A2}'
-        | '\u{1D4A5}'..='\u{1D4A6}'
-        | '\u{1D4A9}'..='\u{1D4AC}'
-        | '\u{1D4AE}'..='\u{1D4B9}'
-        | '\u{1D4BB}'
-        | '\u{1D4BD}'..='\u{1D4C3}'
-        | '\u{1D4C5}'..='\u{1D505}'
-        | '\u{1D507}'..='\u{1D50A}'
-        | '\u{1D50D}'..='\u{1D514}'
-        | '\u{1D516}'..='\u{1D51C}'
-        | '\u{1D51E}'..='\u{1D539}'
-        | '\u{1D53B}'..='\u{1D53E}'
-        | '\u{1D540}'..='\u{1D544}'
-        | '\u{1D546}'
-        | '\u{1D54A}'..='\u{1D550}'
-        | '\u{1D552}'..='\u{1D6A5}'
-        | '\u{1D6A8}'..='\u{1D7CB}'
-        | '\u{1D7CE}'..='\u{1DA8B}'
-        | '\u{1DA9B}'..='\u{1DA9F}'
-        | '\u{1DAA1}'..='\u{1DAAF}'
-        | '\u{1DF00}'..='\u{1DF1E}'
-        | '\u{1DF25}'..='\u{1DF2A}'
-        | '\u{1E000}'..='\u{1E006}'
-        | '\u{1E008}'..='\u{1E018}'
-        | '\u{1E01B}'..='\u{1E021}'
-        | '\u{1E023}'..='\u{1E024}'
-        | '\u{1E026}'..='\u{1E02A}'
-        | '\u{1E030}'..='\u{1E06D}'
-        | '\u{1E08F}'
-        | '\u{1E100}'..='\u{1E12C}'
-        | '\u{1E130}'..='\u{1E13D}'
-        | '\u{1E140}'..='\u{1E149}'
-        | '\u{1E14E}'..='\u{1E14F}'
-        | '\u{1E290}'..='\u{1E2AE}'
-        | '\u{1E2C0}'..='\u{1E2F9}'
-        | '\u{1E2FF}'
-        | '\u{1E4D0}'..='\u{1E4F9}'
-        | '\u{1E5D0}'..='\u{1E5FA}'
-        | '\u{1E5FF}'
-        | '\u{1E7E0}'..='\u{1E7E6}'
-        | '\u{1E7E8}'..='\u{1E7EB}'
-        | '\u{1E7ED}'..='\u{1E7EE}'
-        | '\u{1E7F0}'..='\u{1E7FE}'
-        | '\u{1E800}'..='\u{1E8C4}'
-        | '\u{1E8C7}'..='\u{1E8D6}'
-        | '\u{1E900}'..='\u{1E94B}'
-        | '\u{1E950}'..='\u{1E959}'
-        | '\u{1E95E}'..='\u{1E95F}'
-        | '\u{1EC71}'..='\u{1ECB4}'
-        | '\u{1ED01}'..='\u{1ED3D}'
-        | '\u{1EE00}'..='\u{1EE03}'
-        | '\u{1EE05}'..='\u{1EE1F}'
-        | '\u{1EE21}'..='\u{1EE22}'
-        | '\u{1EE24}'
-        | '\u{1EE27}'
-        | '\u{1EE29}'..='\u{1EE32}'
-        | '\u{1EE34}'..='\u{1EE37}'
-        | '\u{1EE39}'
-        | '\u{1EE3B}'
-        | '\u{1EE42}'
-        | '\u{1EE47}'
-        | '\u{1EE49}'
-        | '\u{1EE4B}'
-        | '\u{1EE4D}'..='\u{1EE4F}'
-        | '\u{1EE51}'..='\u{1EE52}'
-        | '\u{1EE54}'
-        | '\u{1EE57}'
-        | '\u{1EE59}'
-        | '\u{1EE5B}'
-        | '\u{1EE5D}'
-        | '\u{1EE5F}'
-        | '\u{1EE61}'..='\u{1EE62}'
-        | '\u{1EE64}'
-        | '\u{1EE67}'..='\u{1EE6A}'
-        | '\u{1EE6C}'..='\u{1EE72}'
-        | '\u{1EE74}'..='\u{1EE77}'
-        | '\u{1EE79}'..='\u{1EE7C}'
-        | '\u{1EE7E}'
-        | '\u{1EE80}'..='\u{1EE89}'
-        | '\u{1EE8B}'..='\u{1EE9B}'
-        | '\u{1EEA1}'..='\u{1EEA3}'
-        | '\u{1EEA5}'..='\u{1EEA9}'
-        | '\u{1EEAB}'..='\u{1EEBB}'
-        | '\u{1EEF0}'..='\u{1EEF1}'
-        | '\u{1F000}'..='\u{1F02B}'
-        | '\u{1F030}'..='\u{1F093}'
-        | '\u{1F0A0}'..='\u{1F0AE}'
-        | '\u{1F0B1}'..='\u{1F0BF}'
-        | '\u{1F0C1}'..='\u{1F0CF}'
-        | '\u{1F0D1}'..='\u{1F0F5}'
-        | '\u{1F100}'..='\u{1F1AD}'
-        | '\u{1F1E6}'..='\u{1F202}'
-        | '\u{1F210}'..='\u{1F23B}'
-        | '\u{1F240}'..='\u{1F248}'
-        | '\u{1F250}'..='\u{1F251}'
-        | '\u{1F260}'..='\u{1F265}'
-        | '\u{1F300}'..='\u{1F6D7}'
-        | '\u{1F6DC}'..='\u{1F6EC}'
-        | '\u{1F6F0}'..='\u{1F6FC}'
-        | '\u{1F700}'..='\u{1F776}'
-        | '\u{1F77B}'..='\u{1F7D9}'
-        | '\u{1F7E0}'..='\u{1F7EB}'
-        | '\u{1F7F0}'
-        | '\u{1F800}'..='\u{1F80B}'
-        | '\u{1F810}'..='\u{1F847}'
-        | '\u{1F850}'..='\u{1F859}'
-        | '\u{1F860}'..='\u{1F887}'
-        | '\u{1F890}'..='\u{1F8AD}'
-        | '\u{1F8B0}'..='\u{1F8BB}'
-        | '\u{1F8C0}'..='\u{1F8C1}'
-        | '\u{1F900}'..='\u{1FA53}'
-        | '\u{1FA60}'..='\u{1FA6D}'
-        | '\u{1FA70}'..='\u{1FA7C}'
-        | '\u{1FA80}'..='\u{1FA89}'
-        | '\u{1FA8F}'..='\u{1FAC6}'
-        | '\u{1FACE}'..='\u{1FADC}'
-        | '\u{1FADF}'..='\u{1FAE9}'
-        | '\u{1FAF0}'..='\u{1FAF8}'
-        | '\u{1FB00}'..='\u{1FB92}'
-        | '\u{1FB94}'..='\u{1FBF9}'
-        | '\u{20000}'..='\u{2A6DF}'
-        | '\u{2A700}'..='\u{2B739}'
-        | '\u{2B740}'..='\u{2B81D}'
-        | '\u{2B820}'..='\u{2CEA1}'
-        | '\u{2CEB0}'..='\u{2EBE0}'
-        | '\u{2EBF0}'..='\u{2EE5D}'
-        | '\u{2F800}'..='\u{2FA1D}'
-        | '\u{30000}'..='\u{3134A}'
-        | '\u{31350}'..='\u{323AF}'
-        | '\u{E0001}'
-        | '\u{E0020}'..='\u{E007F}'
-        | '\u{E0100}'..='\u{E01EF}' => true,
-        _ => false,
-    }
-}
-
-#[inline]
-#[allow(ellipsis_inclusive_range_patterns)]
-pub fn qc_nfc(c: char) -> IsNormalized {
-    match c {
-        '\u{0340}'..='\u{0341}' => No,
-        '\u{0343}'..='\u{0344}' => No,
-        '\u{0374}' => No,
-        '\u{037E}' => No,
-        '\u{0387}' => No,
-        '\u{0958}'..='\u{095F}' => No,
-        '\u{09DC}'..='\u{09DD}' => No,
-        '\u{09DF}' => No,
-        '\u{0A33}' => No,
-        '\u{0A36}' => No,
-        '\u{0A59}'..='\u{0A5B}' => No,
-        '\u{0A5E}' => No,
-        '\u{0B5C}'..='\u{0B5D}' => No,
-        '\u{0F43}' => No,
-        '\u{0F4D}' => No,
-        '\u{0F52}' => No,
-        '\u{0F57}' => No,
-        '\u{0F5C}' => No,
-        '\u{0F69}' => No,
-        '\u{0F73}' => No,
-        '\u{0F75}'..='\u{0F76}' => No,
-        '\u{0F78}' => No,
-        '\u{0F81}' => No,
-        '\u{0F93}' => No,
-        '\u{0F9D}' => No,
-        '\u{0FA2}' => No,
-        '\u{0FA7}' => No,
-        '\u{0FAC}' => No,
-        '\u{0FB9}' => No,
-        '\u{1F71}' => No,
-        '\u{1F73}' => No,
-        '\u{1F75}' => No,
-        '\u{1F77}' => No,
-        '\u{1F79}' => No,
-        '\u{1F7B}' => No,
-        '\u{1F7D}' => No,
-        '\u{1FBB}' => No,
-        '\u{1FBE}' => No,
-        '\u{1FC9}' => No,
-        '\u{1FCB}' => No,
-        '\u{1FD3}' => No,
-        '\u{1FDB}' => No,
-        '\u{1FE3}' => No,
-        '\u{1FEB}' => No,
-        '\u{1FEE}'..='\u{1FEF}' => No,
-        '\u{1FF9}' => No,
-        '\u{1FFB}' => No,
-        '\u{1FFD}' => No,
-        '\u{2000}'..='\u{2001}' => No,
-        '\u{2126}' => No,
-        '\u{212A}'..='\u{212B}' => No,
-        '\u{2329}' => No,
-        '\u{232A}' => No,
-        '\u{2ADC}' => No,
-        '\u{F900}'..='\u{FA0D}' => No,
-        '\u{FA10}' => No,
-        '\u{FA12}' => No,
-        '\u{FA15}'..='\u{FA1E}' => No,
-        '\u{FA20}' => No,
-        '\u{FA22}' => No,
-        '\u{FA25}'..='\u{FA26}' => No,
-        '\u{FA2A}'..='\u{FA6D}' => No,
-        '\u{FA70}'..='\u{FAD9}' => No,
-        '\u{FB1D}' => No,
-        '\u{FB1F}' => No,
-        '\u{FB2A}'..='\u{FB36}' => No,
-        '\u{FB38}'..='\u{FB3C}' => No,
-        '\u{FB3E}' => No,
-        '\u{FB40}'..='\u{FB41}' => No,
-        '\u{FB43}'..='\u{FB44}' => No,
-        '\u{FB46}'..='\u{FB4E}' => No,
-        '\u{1D15E}'..='\u{1D164}' => No,
-        '\u{1D1BB}'..='\u{1D1C0}' => No,
-        '\u{2F800}'..='\u{2FA1D}' => No,
-        '\u{0300}'..='\u{0304}' => Maybe,
-        '\u{0306}'..='\u{030C}' => Maybe,
-        '\u{030F}' => Maybe,
-        '\u{0311}' => Maybe,
-        '\u{0313}'..='\u{0314}' => Maybe,
-        '\u{031B}' => Maybe,
-        '\u{0323}'..='\u{0328}' => Maybe,
-        '\u{032D}'..='\u{032E}' => Maybe,
-        '\u{0330}'..='\u{0331}' => Maybe,
-        '\u{0338}' => Maybe,
-        '\u{0342}' => Maybe,
-        '\u{0345}' => Maybe,
-        '\u{0653}'..='\u{0655}' => Maybe,
-        '\u{093C}' => Maybe,
-        '\u{09BE}' => Maybe,
-        '\u{09D7}' => Maybe,
-        '\u{0B3E}' => Maybe,
-        '\u{0B56}' => Maybe,
-        '\u{0B57}' => Maybe,
-        '\u{0BBE}' => Maybe,
-        '\u{0BD7}' => Maybe,
-        '\u{0C56}' => Maybe,
-        '\u{0CC2}' => Maybe,
-        '\u{0CD5}'..='\u{0CD6}' => Maybe,
-        '\u{0D3E}' => Maybe,
-        '\u{0D57}' => Maybe,
-        '\u{0DCA}' => Maybe,
-        '\u{0DCF}' => Maybe,
-        '\u{0DDF}' => Maybe,
-        '\u{102E}' => Maybe,
-        '\u{1161}'..='\u{1175}' => Maybe,
-        '\u{11A8}'..='\u{11C2}' => Maybe,
-        '\u{1B35}' => Maybe,
-        '\u{3099}'..='\u{309A}' => Maybe,
-        '\u{110BA}' => Maybe,
-        '\u{11127}' => Maybe,
-        '\u{1133E}' => Maybe,
-        '\u{11357}' => Maybe,
-        '\u{113B8}' => Maybe,
-        '\u{113BB}' => Maybe,
-        '\u{113C2}' => Maybe,
-        '\u{113C5}' => Maybe,
-        '\u{113C7}'..='\u{113C9}' => Maybe,
-        '\u{114B0}' => Maybe,
-        '\u{114BA}' => Maybe,
-        '\u{114BD}' => Maybe,
-        '\u{115AF}' => Maybe,
-        '\u{11930}' => Maybe,
-        '\u{1611E}'..='\u{16129}' => Maybe,
-        '\u{16D67}'..='\u{16D68}' => Maybe,
-        _ => Yes,
-    }
-}
-#[inline]
-#[allow(ellipsis_inclusive_range_patterns)]
-pub fn qc_nfkc(c: char) -> IsNormalized {
-    match c {
-        '\u{00A0}' => No,
-        '\u{00A8}' => No,
-        '\u{00AA}' => No,
-        '\u{00AF}' => No,
-        '\u{00B2}'..='\u{00B3}' => No,
-        '\u{00B4}' => No,
-        '\u{00B5}' => No,
-        '\u{00B8}' => No,
-        '\u{00B9}' => No,
-        '\u{00BA}' => No,
-        '\u{00BC}'..='\u{00BE}' => No,
-        '\u{0132}'..='\u{0133}' => No,
-        '\u{013F}'..='\u{0140}' => No,
-        '\u{0149}' => No,
-        '\u{017F}' => No,
-        '\u{01C4}'..='\u{01CC}' => No,
-        '\u{01F1}'..='\u{01F3}' => No,
-        '\u{02B0}'..='\u{02B8}' => No,
-        '\u{02D8}'..='\u{02DD}' => No,
-        '\u{02E0}'..='\u{02E4}' => No,
-        '\u{0340}'..='\u{0341}' => No,
-        '\u{0343}'..='\u{0344}' => No,
-        '\u{0374}' => No,
-        '\u{037A}' => No,
-        '\u{037E}' => No,
-        '\u{0384}'..='\u{0385}' => No,
-        '\u{0387}' => No,
-        '\u{03D0}'..='\u{03D6}' => No,
-        '\u{03F0}'..='\u{03F2}' => No,
-        '\u{03F4}'..='\u{03F5}' => No,
-        '\u{03F9}' => No,
-        '\u{0587}' => No,
-        '\u{0675}'..='\u{0678}' => No,
-        '\u{0958}'..='\u{095F}' => No,
-        '\u{09DC}'..='\u{09DD}' => No,
-        '\u{09DF}' => No,
-        '\u{0A33}' => No,
-        '\u{0A36}' => No,
-        '\u{0A59}'..='\u{0A5B}' => No,
-        '\u{0A5E}' => No,
-        '\u{0B5C}'..='\u{0B5D}' => No,
-        '\u{0E33}' => No,
-        '\u{0EB3}' => No,
-        '\u{0EDC}'..='\u{0EDD}' => No,
-        '\u{0F0C}' => No,
-        '\u{0F43}' => No,
-        '\u{0F4D}' => No,
-        '\u{0F52}' => No,
-        '\u{0F57}' => No,
-        '\u{0F5C}' => No,
-        '\u{0F69}' => No,
-        '\u{0F73}' => No,
-        '\u{0F75}'..='\u{0F79}' => No,
-        '\u{0F81}' => No,
-        '\u{0F93}' => No,
-        '\u{0F9D}' => No,
-        '\u{0FA2}' => No,
-        '\u{0FA7}' => No,
-        '\u{0FAC}' => No,
-        '\u{0FB9}' => No,
-        '\u{10FC}' => No,
-        '\u{1D2C}'..='\u{1D2E}' => No,
-        '\u{1D30}'..='\u{1D3A}' => No,
-        '\u{1D3C}'..='\u{1D4D}' => No,
-        '\u{1D4F}'..='\u{1D6A}' => No,
-        '\u{1D78}' => No,
-        '\u{1D9B}'..='\u{1DBF}' => No,
-        '\u{1E9A}'..='\u{1E9B}' => No,
-        '\u{1F71}' => No,
-        '\u{1F73}' => No,
-        '\u{1F75}' => No,
-        '\u{1F77}' => No,
-        '\u{1F79}' => No,
-        '\u{1F7B}' => No,
-        '\u{1F7D}' => No,
-        '\u{1FBB}' => No,
-        '\u{1FBD}' => No,
-        '\u{1FBE}' => No,
-        '\u{1FBF}'..='\u{1FC1}' => No,
-        '\u{1FC9}' => No,
-        '\u{1FCB}' => No,
-        '\u{1FCD}'..='\u{1FCF}' => No,
-        '\u{1FD3}' => No,
-        '\u{1FDB}' => No,
-        '\u{1FDD}'..='\u{1FDF}' => No,
-        '\u{1FE3}' => No,
-        '\u{1FEB}' => No,
-        '\u{1FED}'..='\u{1FEF}' => No,
-        '\u{1FF9}' => No,
-        '\u{1FFB}' => No,
-        '\u{1FFD}'..='\u{1FFE}' => No,
-        '\u{2000}'..='\u{200A}' => No,
-        '\u{2011}' => No,
-        '\u{2017}' => No,
-        '\u{2024}'..='\u{2026}' => No,
-        '\u{202F}' => No,
-        '\u{2033}'..='\u{2034}' => No,
-        '\u{2036}'..='\u{2037}' => No,
-        '\u{203C}' => No,
-        '\u{203E}' => No,
-        '\u{2047}'..='\u{2049}' => No,
-        '\u{2057}' => No,
-        '\u{205F}' => No,
-        '\u{2070}' => No,
-        '\u{2071}' => No,
-        '\u{2074}'..='\u{2079}' => No,
-        '\u{207A}'..='\u{207C}' => No,
-        '\u{207D}' => No,
-        '\u{207E}' => No,
-        '\u{207F}' => No,
-        '\u{2080}'..='\u{2089}' => No,
-        '\u{208A}'..='\u{208C}' => No,
-        '\u{208D}' => No,
-        '\u{208E}' => No,
-        '\u{2090}'..='\u{209C}' => No,
-        '\u{20A8}' => No,
-        '\u{2100}'..='\u{2101}' => No,
-        '\u{2102}' => No,
-        '\u{2103}' => No,
-        '\u{2105}'..='\u{2106}' => No,
-        '\u{2107}' => No,
-        '\u{2109}' => No,
-        '\u{210A}'..='\u{2113}' => No,
-        '\u{2115}' => No,
-        '\u{2116}' => No,
-        '\u{2119}'..='\u{211D}' => No,
-        '\u{2120}'..='\u{2122}' => No,
-        '\u{2124}' => No,
-        '\u{2126}' => No,
-        '\u{2128}' => No,
-        '\u{212A}'..='\u{212D}' => No,
-        '\u{212F}'..='\u{2131}' => No,
-        '\u{2133}'..='\u{2134}' => No,
-        '\u{2135}'..='\u{2138}' => No,
-        '\u{2139}' => No,
-        '\u{213B}' => No,
-        '\u{213C}'..='\u{213F}' => No,
-        '\u{2140}' => No,
-        '\u{2145}'..='\u{2149}' => No,
-        '\u{2150}'..='\u{215F}' => No,
-        '\u{2160}'..='\u{217F}' => No,
-        '\u{2189}' => No,
-        '\u{222C}'..='\u{222D}' => No,
-        '\u{222F}'..='\u{2230}' => No,
-        '\u{2329}' => No,
-        '\u{232A}' => No,
-        '\u{2460}'..='\u{249B}' => No,
-        '\u{249C}'..='\u{24E9}' => No,
-        '\u{24EA}' => No,
-        '\u{2A0C}' => No,
-        '\u{2A74}'..='\u{2A76}' => No,
-        '\u{2ADC}' => No,
-        '\u{2C7C}'..='\u{2C7D}' => No,
-        '\u{2D6F}' => No,
-        '\u{2E9F}' => No,
-        '\u{2EF3}' => No,
-        '\u{2F00}'..='\u{2FD5}' => No,
-        '\u{3000}' => No,
-        '\u{3036}' => No,
-        '\u{3038}'..='\u{303A}' => No,
-        '\u{309B}'..='\u{309C}' => No,
-        '\u{309F}' => No,
-        '\u{30FF}' => No,
-        '\u{3131}'..='\u{318E}' => No,
-        '\u{3192}'..='\u{3195}' => No,
-        '\u{3196}'..='\u{319F}' => No,
-        '\u{3200}'..='\u{321E}' => No,
-        '\u{3220}'..='\u{3229}' => No,
-        '\u{322A}'..='\u{3247}' => No,
-        '\u{3250}' => No,
-        '\u{3251}'..='\u{325F}' => No,
-        '\u{3260}'..='\u{327E}' => No,
-        '\u{3280}'..='\u{3289}' => No,
-        '\u{328A}'..='\u{32B0}' => No,
-        '\u{32B1}'..='\u{32BF}' => No,
-        '\u{32C0}'..='\u{33FF}' => No,
-        '\u{A69C}'..='\u{A69D}' => No,
-        '\u{A770}' => No,
-        '\u{A7F2}'..='\u{A7F4}' => No,
-        '\u{A7F8}'..='\u{A7F9}' => No,
-        '\u{AB5C}'..='\u{AB5F}' => No,
-        '\u{AB69}' => No,
-        '\u{F900}'..='\u{FA0D}' => No,
-        '\u{FA10}' => No,
-        '\u{FA12}' => No,
-        '\u{FA15}'..='\u{FA1E}' => No,
-        '\u{FA20}' => No,
-        '\u{FA22}' => No,
-        '\u{FA25}'..='\u{FA26}' => No,
-        '\u{FA2A}'..='\u{FA6D}' => No,
-        '\u{FA70}'..='\u{FAD9}' => No,
-        '\u{FB00}'..='\u{FB06}' => No,
-        '\u{FB13}'..='\u{FB17}' => No,
-        '\u{FB1D}' => No,
-        '\u{FB1F}'..='\u{FB28}' => No,
-        '\u{FB29}' => No,
-        '\u{FB2A}'..='\u{FB36}' => No,
-        '\u{FB38}'..='\u{FB3C}' => No,
-        '\u{FB3E}' => No,
-        '\u{FB40}'..='\u{FB41}' => No,
-        '\u{FB43}'..='\u{FB44}' => No,
-        '\u{FB46}'..='\u{FBB1}' => No,
-        '\u{FBD3}'..='\u{FD3D}' => No,
-        '\u{FD50}'..='\u{FD8F}' => No,
-        '\u{FD92}'..='\u{FDC7}' => No,
-        '\u{FDF0}'..='\u{FDFB}' => No,
-        '\u{FDFC}' => No,
-        '\u{FE10}'..='\u{FE16}' => No,
-        '\u{FE17}' => No,
-        '\u{FE18}' => No,
-        '\u{FE19}' => No,
-        '\u{FE30}' => No,
-        '\u{FE31}'..='\u{FE32}' => No,
-        '\u{FE33}'..='\u{FE34}' => No,
-        '\u{FE35}' => No,
-        '\u{FE36}' => No,
-        '\u{FE37}' => No,
-        '\u{FE38}' => No,
-        '\u{FE39}' => No,
-        '\u{FE3A}' => No,
-        '\u{FE3B}' => No,
-        '\u{FE3C}' => No,
-        '\u{FE3D}' => No,
-        '\u{FE3E}' => No,
-        '\u{FE3F}' => No,
-        '\u{FE40}' => No,
-        '\u{FE41}' => No,
-        '\u{FE42}' => No,
-        '\u{FE43}' => No,
-        '\u{FE44}' => No,
-        '\u{FE47}' => No,
-        '\u{FE48}' => No,
-        '\u{FE49}'..='\u{FE4C}' => No,
-        '\u{FE4D}'..='\u{FE4F}' => No,
-        '\u{FE50}'..='\u{FE52}' => No,
-        '\u{FE54}'..='\u{FE57}' => No,
-        '\u{FE58}' => No,
-        '\u{FE59}' => No,
-        '\u{FE5A}' => No,
-        '\u{FE5B}' => No,
-        '\u{FE5C}' => No,
-        '\u{FE5D}' => No,
-        '\u{FE5E}' => No,
-        '\u{FE5F}'..='\u{FE61}' => No,
-        '\u{FE62}' => No,
-        '\u{FE63}' => No,
-        '\u{FE64}'..='\u{FE66}' => No,
-        '\u{FE68}' => No,
-        '\u{FE69}' => No,
-        '\u{FE6A}'..='\u{FE6B}' => No,
-        '\u{FE70}'..='\u{FE72}' => No,
-        '\u{FE74}' => No,
-        '\u{FE76}'..='\u{FEFC}' => No,
-        '\u{FF01}'..='\u{FF03}' => No,
-        '\u{FF04}' => No,
-        '\u{FF05}'..='\u{FF07}' => No,
-        '\u{FF08}' => No,
-        '\u{FF09}' => No,
-        '\u{FF0A}' => No,
-        '\u{FF0B}' => No,
-        '\u{FF0C}' => No,
-        '\u{FF0D}' => No,
-        '\u{FF0E}'..='\u{FF0F}' => No,
-        '\u{FF10}'..='\u{FF19}' => No,
-        '\u{FF1A}'..='\u{FF1B}' => No,
-        '\u{FF1C}'..='\u{FF1E}' => No,
-        '\u{FF1F}'..='\u{FF20}' => No,
-        '\u{FF21}'..='\u{FF3A}' => No,
-        '\u{FF3B}' => No,
-        '\u{FF3C}' => No,
-        '\u{FF3D}' => No,
-        '\u{FF3E}' => No,
-        '\u{FF3F}' => No,
-        '\u{FF40}' => No,
-        '\u{FF41}'..='\u{FF5A}' => No,
-        '\u{FF5B}' => No,
-        '\u{FF5C}' => No,
-        '\u{FF5D}' => No,
-        '\u{FF5E}' => No,
-        '\u{FF5F}' => No,
-        '\u{FF60}' => No,
-        '\u{FF61}' => No,
-        '\u{FF62}' => No,
-        '\u{FF63}' => No,
-        '\u{FF64}'..='\u{FF65}' => No,
-        '\u{FF66}'..='\u{FF6F}' => No,
-        '\u{FF70}' => No,
-        '\u{FF71}'..='\u{FF9D}' => No,
-        '\u{FF9E}'..='\u{FF9F}' => No,
-        '\u{FFA0}'..='\u{FFBE}' => No,
-        '\u{FFC2}'..='\u{FFC7}' => No,
-        '\u{FFCA}'..='\u{FFCF}' => No,
-        '\u{FFD2}'..='\u{FFD7}' => No,
-        '\u{FFDA}'..='\u{FFDC}' => No,
-        '\u{FFE0}'..='\u{FFE1}' => No,
-        '\u{FFE2}' => No,
-        '\u{FFE3}' => No,
-        '\u{FFE4}' => No,
-        '\u{FFE5}'..='\u{FFE6}' => No,
-        '\u{FFE8}' => No,
-        '\u{FFE9}'..='\u{FFEC}' => No,
-        '\u{FFED}'..='\u{FFEE}' => No,
-        '\u{10781}'..='\u{10785}' => No,
-        '\u{10787}'..='\u{107B0}' => No,
-        '\u{107B2}'..='\u{107BA}' => No,
-        '\u{1CCD6}'..='\u{1CCEF}' => No,
-        '\u{1CCF0}'..='\u{1CCF9}' => No,
-        '\u{1D15E}'..='\u{1D164}' => No,
-        '\u{1D1BB}'..='\u{1D1C0}' => No,
-        '\u{1D400}'..='\u{1D454}' => No,
-        '\u{1D456}'..='\u{1D49C}' => No,
-        '\u{1D49E}'..='\u{1D49F}' => No,
-        '\u{1D4A2}' => No,
-        '\u{1D4A5}'..='\u{1D4A6}' => No,
-        '\u{1D4A9}'..='\u{1D4AC}' => No,
-        '\u{1D4AE}'..='\u{1D4B9}' => No,
-        '\u{1D4BB}' => No,
-        '\u{1D4BD}'..='\u{1D4C3}' => No,
-        '\u{1D4C5}'..='\u{1D505}' => No,
-        '\u{1D507}'..='\u{1D50A}' => No,
-        '\u{1D50D}'..='\u{1D514}' => No,
-        '\u{1D516}'..='\u{1D51C}' => No,
-        '\u{1D51E}'..='\u{1D539}' => No,
-        '\u{1D53B}'..='\u{1D53E}' => No,
-        '\u{1D540}'..='\u{1D544}' => No,
-        '\u{1D546}' => No,
-        '\u{1D54A}'..='\u{1D550}' => No,
-        '\u{1D552}'..='\u{1D6A5}' => No,
-        '\u{1D6A8}'..='\u{1D6C0}' => No,
-        '\u{1D6C1}' => No,
-        '\u{1D6C2}'..='\u{1D6DA}' => No,
-        '\u{1D6DB}' => No,
-        '\u{1D6DC}'..='\u{1D6FA}' => No,
-        '\u{1D6FB}' => No,
-        '\u{1D6FC}'..='\u{1D714}' => No,
-        '\u{1D715}' => No,
-        '\u{1D716}'..='\u{1D734}' => No,
-        '\u{1D735}' => No,
-        '\u{1D736}'..='\u{1D74E}' => No,
-        '\u{1D74F}' => No,
-        '\u{1D750}'..='\u{1D76E}' => No,
-        '\u{1D76F}' => No,
-        '\u{1D770}'..='\u{1D788}' => No,
-        '\u{1D789}' => No,
-        '\u{1D78A}'..='\u{1D7A8}' => No,
-        '\u{1D7A9}' => No,
-        '\u{1D7AA}'..='\u{1D7C2}' => No,
-        '\u{1D7C3}' => No,
-        '\u{1D7C4}'..='\u{1D7CB}' => No,
-        '\u{1D7CE}'..='\u{1D7FF}' => No,
-        '\u{1E030}'..='\u{1E06D}' => No,
-        '\u{1EE00}'..='\u{1EE03}' => No,
-        '\u{1EE05}'..='\u{1EE1F}' => No,
-        '\u{1EE21}'..='\u{1EE22}' => No,
-        '\u{1EE24}' => No,
-        '\u{1EE27}' => No,
-        '\u{1EE29}'..='\u{1EE32}' => No,
-        '\u{1EE34}'..='\u{1EE37}' => No,
-        '\u{1EE39}' => No,
-        '\u{1EE3B}' => No,
-        '\u{1EE42}' => No,
-        '\u{1EE47}' => No,
-        '\u{1EE49}' => No,
-        '\u{1EE4B}' => No,
-        '\u{1EE4D}'..='\u{1EE4F}' => No,
-        '\u{1EE51}'..='\u{1EE52}' => No,
-        '\u{1EE54}' => No,
-        '\u{1EE57}' => No,
-        '\u{1EE59}' => No,
-        '\u{1EE5B}' => No,
-        '\u{1EE5D}' => No,
-        '\u{1EE5F}' => No,
-        '\u{1EE61}'..='\u{1EE62}' => No,
-        '\u{1EE64}' => No,
-        '\u{1EE67}'..='\u{1EE6A}' => No,
-        '\u{1EE6C}'..='\u{1EE72}' => No,
-        '\u{1EE74}'..='\u{1EE77}' => No,
-        '\u{1EE79}'..='\u{1EE7C}' => No,
-        '\u{1EE7E}' => No,
-        '\u{1EE80}'..='\u{1EE89}' => No,
-        '\u{1EE8B}'..='\u{1EE9B}' => No,
-        '\u{1EEA1}'..='\u{1EEA3}' => No,
-        '\u{1EEA5}'..='\u{1EEA9}' => No,
-        '\u{1EEAB}'..='\u{1EEBB}' => No,
-        '\u{1F100}'..='\u{1F10A}' => No,
-        '\u{1F110}'..='\u{1F12E}' => No,
-        '\u{1F130}'..='\u{1F14F}' => No,
-        '\u{1F16A}'..='\u{1F16C}' => No,
-        '\u{1F190}' => No,
-        '\u{1F200}'..='\u{1F202}' => No,
-        '\u{1F210}'..='\u{1F23B}' => No,
-        '\u{1F240}'..='\u{1F248}' => No,
-        '\u{1F250}'..='\u{1F251}' => No,
-        '\u{1FBF0}'..='\u{1FBF9}' => No,
-        '\u{2F800}'..='\u{2FA1D}' => No,
-        '\u{0300}'..='\u{0304}' => Maybe,
-        '\u{0306}'..='\u{030C}' => Maybe,
-        '\u{030F}' => Maybe,
-        '\u{0311}' => Maybe,
-        '\u{0313}'..='\u{0314}' => Maybe,
-        '\u{031B}' => Maybe,
-        '\u{0323}'..='\u{0328}' => Maybe,
-        '\u{032D}'..='\u{032E}' => Maybe,
-        '\u{0330}'..='\u{0331}' => Maybe,
-        '\u{0338}' => Maybe,
-        '\u{0342}' => Maybe,
-        '\u{0345}' => Maybe,
-        '\u{0653}'..='\u{0655}' => Maybe,
-        '\u{093C}' => Maybe,
-        '\u{09BE}' => Maybe,
-        '\u{09D7}' => Maybe,
-        '\u{0B3E}' => Maybe,
-        '\u{0B56}' => Maybe,
-        '\u{0B57}' => Maybe,
-        '\u{0BBE}' => Maybe,
-        '\u{0BD7}' => Maybe,
-        '\u{0C56}' => Maybe,
-        '\u{0CC2}' => Maybe,
-        '\u{0CD5}'..='\u{0CD6}' => Maybe,
-        '\u{0D3E}' => Maybe,
-        '\u{0D57}' => Maybe,
-        '\u{0DCA}' => Maybe,
-        '\u{0DCF}' => Maybe,
-        '\u{0DDF}' => Maybe,
-        '\u{102E}' => Maybe,
-        '\u{1161}'..='\u{1175}' => Maybe,
-        '\u{11A8}'..='\u{11C2}' => Maybe,
-        '\u{1B35}' => Maybe,
-        '\u{3099}'..='\u{309A}' => Maybe,
-        '\u{110BA}' => Maybe,
-        '\u{11127}' => Maybe,
-        '\u{1133E}' => Maybe,
-        '\u{11357}' => Maybe,
-        '\u{113B8}' => Maybe,
-        '\u{113BB}' => Maybe,
-        '\u{113C2}' => Maybe,
-        '\u{113C5}' => Maybe,
-        '\u{113C7}'..='\u{113C9}' => Maybe,
-        '\u{114B0}' => Maybe,
-        '\u{114BA}' => Maybe,
-        '\u{114BD}' => Maybe,
-        '\u{115AF}' => Maybe,
-        '\u{11930}' => Maybe,
-        '\u{1611E}'..='\u{16129}' => Maybe,
-        '\u{16D67}'..='\u{16D68}' => Maybe,
-        _ => Yes,
-    }
-}
-#[inline]
-#[allow(ellipsis_inclusive_range_patterns)]
-pub fn qc_nfd(c: char) -> IsNormalized {
-    match c {
-        '\u{00C0}'..='\u{00C5}' => No,
-        '\u{00C7}'..='\u{00CF}' => No,
-        '\u{00D1}'..='\u{00D6}' => No,
-        '\u{00D9}'..='\u{00DD}' => No,
-        '\u{00E0}'..='\u{00E5}' => No,
-        '\u{00E7}'..='\u{00EF}' => No,
-        '\u{00F1}'..='\u{00F6}' => No,
-        '\u{00F9}'..='\u{00FD}' => No,
-        '\u{00FF}'..='\u{010F}' => No,
-        '\u{0112}'..='\u{0125}' => No,
-        '\u{0128}'..='\u{0130}' => No,
-        '\u{0134}'..='\u{0137}' => No,
-        '\u{0139}'..='\u{013E}' => No,
-        '\u{0143}'..='\u{0148}' => No,
-        '\u{014C}'..='\u{0151}' => No,
-        '\u{0154}'..='\u{0165}' => No,
-        '\u{0168}'..='\u{017E}' => No,
-        '\u{01A0}'..='\u{01A1}' => No,
-        '\u{01AF}'..='\u{01B0}' => No,
-        '\u{01CD}'..='\u{01DC}' => No,
-        '\u{01DE}'..='\u{01E3}' => No,
-        '\u{01E6}'..='\u{01F0}' => No,
-        '\u{01F4}'..='\u{01F5}' => No,
-        '\u{01F8}'..='\u{021B}' => No,
-        '\u{021E}'..='\u{021F}' => No,
-        '\u{0226}'..='\u{0233}' => No,
-        '\u{0340}'..='\u{0341}' => No,
-        '\u{0343}'..='\u{0344}' => No,
-        '\u{0374}' => No,
-        '\u{037E}' => No,
-        '\u{0385}' => No,
-        '\u{0386}' => No,
-        '\u{0387}' => No,
-        '\u{0388}'..='\u{038A}' => No,
-        '\u{038C}' => No,
-        '\u{038E}'..='\u{0390}' => No,
-        '\u{03AA}'..='\u{03B0}' => No,
-        '\u{03CA}'..='\u{03CE}' => No,
-        '\u{03D3}'..='\u{03D4}' => No,
-        '\u{0400}'..='\u{0401}' => No,
-        '\u{0403}' => No,
-        '\u{0407}' => No,
-        '\u{040C}'..='\u{040E}' => No,
-        '\u{0419}' => No,
-        '\u{0439}' => No,
-        '\u{0450}'..='\u{0451}' => No,
-        '\u{0453}' => No,
-        '\u{0457}' => No,
-        '\u{045C}'..='\u{045E}' => No,
-        '\u{0476}'..='\u{0477}' => No,
-        '\u{04C1}'..='\u{04C2}' => No,
-        '\u{04D0}'..='\u{04D3}' => No,
-        '\u{04D6}'..='\u{04D7}' => No,
-        '\u{04DA}'..='\u{04DF}' => No,
-        '\u{04E2}'..='\u{04E7}' => No,
-        '\u{04EA}'..='\u{04F5}' => No,
-        '\u{04F8}'..='\u{04F9}' => No,
-        '\u{0622}'..='\u{0626}' => No,
-        '\u{06C0}' => No,
-        '\u{06C2}' => No,
-        '\u{06D3}' => No,
-        '\u{0929}' => No,
-        '\u{0931}' => No,
-        '\u{0934}' => No,
-        '\u{0958}'..='\u{095F}' => No,
-        '\u{09CB}'..='\u{09CC}' => No,
-        '\u{09DC}'..='\u{09DD}' => No,
-        '\u{09DF}' => No,
-        '\u{0A33}' => No,
-        '\u{0A36}' => No,
-        '\u{0A59}'..='\u{0A5B}' => No,
-        '\u{0A5E}' => No,
-        '\u{0B48}' => No,
-        '\u{0B4B}'..='\u{0B4C}' => No,
-        '\u{0B5C}'..='\u{0B5D}' => No,
-        '\u{0B94}' => No,
-        '\u{0BCA}'..='\u{0BCC}' => No,
-        '\u{0C48}' => No,
-        '\u{0CC0}' => No,
-        '\u{0CC7}'..='\u{0CC8}' => No,
-        '\u{0CCA}'..='\u{0CCB}' => No,
-        '\u{0D4A}'..='\u{0D4C}' => No,
-        '\u{0DDA}' => No,
-        '\u{0DDC}'..='\u{0DDE}' => No,
-        '\u{0F43}' => No,
-        '\u{0F4D}' => No,
-        '\u{0F52}' => No,
-        '\u{0F57}' => No,
-        '\u{0F5C}' => No,
-        '\u{0F69}' => No,
-        '\u{0F73}' => No,
-        '\u{0F75}'..='\u{0F76}' => No,
-        '\u{0F78}' => No,
-        '\u{0F81}' => No,
-        '\u{0F93}' => No,
-        '\u{0F9D}' => No,
-        '\u{0FA2}' => No,
-        '\u{0FA7}' => No,
-        '\u{0FAC}' => No,
-        '\u{0FB9}' => No,
-        '\u{1026}' => No,
-        '\u{1B06}' => No,
-        '\u{1B08}' => No,
-        '\u{1B0A}' => No,
-        '\u{1B0C}' => No,
-        '\u{1B0E}' => No,
-        '\u{1B12}' => No,
-        '\u{1B3B}' => No,
-        '\u{1B3D}' => No,
-        '\u{1B40}'..='\u{1B41}' => No,
-        '\u{1B43}' => No,
-        '\u{1E00}'..='\u{1E99}' => No,
-        '\u{1E9B}' => No,
-        '\u{1EA0}'..='\u{1EF9}' => No,
-        '\u{1F00}'..='\u{1F15}' => No,
-        '\u{1F18}'..='\u{1F1D}' => No,
-        '\u{1F20}'..='\u{1F45}' => No,
-        '\u{1F48}'..='\u{1F4D}' => No,
-        '\u{1F50}'..='\u{1F57}' => No,
-        '\u{1F59}' => No,
-        '\u{1F5B}' => No,
-        '\u{1F5D}' => No,
-        '\u{1F5F}'..='\u{1F7D}' => No,
-        '\u{1F80}'..='\u{1FB4}' => No,
-        '\u{1FB6}'..='\u{1FBC}' => No,
-        '\u{1FBE}' => No,
-        '\u{1FC1}' => No,
-        '\u{1FC2}'..='\u{1FC4}' => No,
-        '\u{1FC6}'..='\u{1FCC}' => No,
-        '\u{1FCD}'..='\u{1FCF}' => No,
-        '\u{1FD0}'..='\u{1FD3}' => No,
-        '\u{1FD6}'..='\u{1FDB}' => No,
-        '\u{1FDD}'..='\u{1FDF}' => No,
-        '\u{1FE0}'..='\u{1FEC}' => No,
-        '\u{1FED}'..='\u{1FEF}' => No,
-        '\u{1FF2}'..='\u{1FF4}' => No,
-        '\u{1FF6}'..='\u{1FFC}' => No,
-        '\u{1FFD}' => No,
-        '\u{2000}'..='\u{2001}' => No,
-        '\u{2126}' => No,
-        '\u{212A}'..='\u{212B}' => No,
-        '\u{219A}'..='\u{219B}' => No,
-        '\u{21AE}' => No,
-        '\u{21CD}' => No,
-        '\u{21CE}'..='\u{21CF}' => No,
-        '\u{2204}' => No,
-        '\u{2209}' => No,
-        '\u{220C}' => No,
-        '\u{2224}' => No,
-        '\u{2226}' => No,
-        '\u{2241}' => No,
-        '\u{2244}' => No,
-        '\u{2247}' => No,
-        '\u{2249}' => No,
-        '\u{2260}' => No,
-        '\u{2262}' => No,
-        '\u{226D}'..='\u{2271}' => No,
-        '\u{2274}'..='\u{2275}' => No,
-        '\u{2278}'..='\u{2279}' => No,
-        '\u{2280}'..='\u{2281}' => No,
-        '\u{2284}'..='\u{2285}' => No,
-        '\u{2288}'..='\u{2289}' => No,
-        '\u{22AC}'..='\u{22AF}' => No,
-        '\u{22E0}'..='\u{22E3}' => No,
-        '\u{22EA}'..='\u{22ED}' => No,
-        '\u{2329}' => No,
-        '\u{232A}' => No,
-        '\u{2ADC}' => No,
-        '\u{304C}' => No,
-        '\u{304E}' => No,
-        '\u{3050}' => No,
-        '\u{3052}' => No,
-        '\u{3054}' => No,
-        '\u{3056}' => No,
-        '\u{3058}' => No,
-        '\u{305A}' => No,
-        '\u{305C}' => No,
-        '\u{305E}' => No,
-        '\u{3060}' => No,
-        '\u{3062}' => No,
-        '\u{3065}' => No,
-        '\u{3067}' => No,
-        '\u{3069}' => No,
-        '\u{3070}'..='\u{3071}' => No,
-        '\u{3073}'..='\u{3074}' => No,
-        '\u{3076}'..='\u{3077}' => No,
-        '\u{3079}'..='\u{307A}' => No,
-        '\u{307C}'..='\u{307D}' => No,
-        '\u{3094}' => No,
-        '\u{309E}' => No,
-        '\u{30AC}' => No,
-        '\u{30AE}' => No,
-        '\u{30B0}' => No,
-        '\u{30B2}' => No,
-        '\u{30B4}' => No,
-        '\u{30B6}' => No,
-        '\u{30B8}' => No,
-        '\u{30BA}' => No,
-        '\u{30BC}' => No,
-        '\u{30BE}' => No,
-        '\u{30C0}' => No,
-        '\u{30C2}' => No,
-        '\u{30C5}' => No,
-        '\u{30C7}' => No,
-        '\u{30C9}' => No,
-        '\u{30D0}'..='\u{30D1}' => No,
-        '\u{30D3}'..='\u{30D4}' => No,
-        '\u{30D6}'..='\u{30D7}' => No,
-        '\u{30D9}'..='\u{30DA}' => No,
-        '\u{30DC}'..='\u{30DD}' => No,
-        '\u{30F4}' => No,
-        '\u{30F7}'..='\u{30FA}' => No,
-        '\u{30FE}' => No,
-        '\u{AC00}'..='\u{D7A3}' => No,
-        '\u{F900}'..='\u{FA0D}' => No,
-        '\u{FA10}' => No,
-        '\u{FA12}' => No,
-        '\u{FA15}'..='\u{FA1E}' => No,
-        '\u{FA20}' => No,
-        '\u{FA22}' => No,
-        '\u{FA25}'..='\u{FA26}' => No,
-        '\u{FA2A}'..='\u{FA6D}' => No,
-        '\u{FA70}'..='\u{FAD9}' => No,
-        '\u{FB1D}' => No,
-        '\u{FB1F}' => No,
-        '\u{FB2A}'..='\u{FB36}' => No,
-        '\u{FB38}'..='\u{FB3C}' => No,
-        '\u{FB3E}' => No,
-        '\u{FB40}'..='\u{FB41}' => No,
-        '\u{FB43}'..='\u{FB44}' => No,
-        '\u{FB46}'..='\u{FB4E}' => No,
-        '\u{105C9}' => No,
-        '\u{105E4}' => No,
-        '\u{1109A}' => No,
-        '\u{1109C}' => No,
-        '\u{110AB}' => No,
-        '\u{1112E}'..='\u{1112F}' => No,
-        '\u{1134B}'..='\u{1134C}' => No,
-        '\u{11383}' => No,
-        '\u{11385}' => No,
-        '\u{1138E}' => No,
-        '\u{11391}' => No,
-        '\u{113C5}' => No,
-        '\u{113C7}'..='\u{113C8}' => No,
-        '\u{114BB}'..='\u{114BC}' => No,
-        '\u{114BE}' => No,
-        '\u{115BA}'..='\u{115BB}' => No,
-        '\u{11938}' => No,
-        '\u{16121}'..='\u{16128}' => No,
-        '\u{16D68}'..='\u{16D6A}' => No,
-        '\u{1D15E}'..='\u{1D164}' => No,
-        '\u{1D1BB}'..='\u{1D1C0}' => No,
-        '\u{2F800}'..='\u{2FA1D}' => No,
-        _ => Yes,
-    }
-}
-#[inline]
-#[allow(ellipsis_inclusive_range_patterns)]
-pub fn qc_nfkd(c: char) -> IsNormalized {
-    match c {
-        '\u{00A0}' => No,
-        '\u{00A8}' => No,
-        '\u{00AA}' => No,
-        '\u{00AF}' => No,
-        '\u{00B2}'..='\u{00B3}' => No,
-        '\u{00B4}' => No,
-        '\u{00B5}' => No,
-        '\u{00B8}' => No,
-        '\u{00B9}' => No,
-        '\u{00BA}' => No,
-        '\u{00BC}'..='\u{00BE}' => No,
-        '\u{00C0}'..='\u{00C5}' => No,
-        '\u{00C7}'..='\u{00CF}' => No,
-        '\u{00D1}'..='\u{00D6}' => No,
-        '\u{00D9}'..='\u{00DD}' => No,
-        '\u{00E0}'..='\u{00E5}' => No,
-        '\u{00E7}'..='\u{00EF}' => No,
-        '\u{00F1}'..='\u{00F6}' => No,
-        '\u{00F9}'..='\u{00FD}' => No,
-        '\u{00FF}'..='\u{010F}' => No,
-        '\u{0112}'..='\u{0125}' => No,
-        '\u{0128}'..='\u{0130}' => No,
-        '\u{0132}'..='\u{0137}' => No,
-        '\u{0139}'..='\u{0140}' => No,
-        '\u{0143}'..='\u{0149}' => No,
-        '\u{014C}'..='\u{0151}' => No,
-        '\u{0154}'..='\u{0165}' => No,
-        '\u{0168}'..='\u{017F}' => No,
-        '\u{01A0}'..='\u{01A1}' => No,
-        '\u{01AF}'..='\u{01B0}' => No,
-        '\u{01C4}'..='\u{01DC}' => No,
-        '\u{01DE}'..='\u{01E3}' => No,
-        '\u{01E6}'..='\u{01F5}' => No,
-        '\u{01F8}'..='\u{021B}' => No,
-        '\u{021E}'..='\u{021F}' => No,
-        '\u{0226}'..='\u{0233}' => No,
-        '\u{02B0}'..='\u{02B8}' => No,
-        '\u{02D8}'..='\u{02DD}' => No,
-        '\u{02E0}'..='\u{02E4}' => No,
-        '\u{0340}'..='\u{0341}' => No,
-        '\u{0343}'..='\u{0344}' => No,
-        '\u{0374}' => No,
-        '\u{037A}' => No,
-        '\u{037E}' => No,
-        '\u{0384}'..='\u{0385}' => No,
-        '\u{0386}' => No,
-        '\u{0387}' => No,
-        '\u{0388}'..='\u{038A}' => No,
-        '\u{038C}' => No,
-        '\u{038E}'..='\u{0390}' => No,
-        '\u{03AA}'..='\u{03B0}' => No,
-        '\u{03CA}'..='\u{03CE}' => No,
-        '\u{03D0}'..='\u{03D6}' => No,
-        '\u{03F0}'..='\u{03F2}' => No,
-        '\u{03F4}'..='\u{03F5}' => No,
-        '\u{03F9}' => No,
-        '\u{0400}'..='\u{0401}' => No,
-        '\u{0403}' => No,
-        '\u{0407}' => No,
-        '\u{040C}'..='\u{040E}' => No,
-        '\u{0419}' => No,
-        '\u{0439}' => No,
-        '\u{0450}'..='\u{0451}' => No,
-        '\u{0453}' => No,
-        '\u{0457}' => No,
-        '\u{045C}'..='\u{045E}' => No,
-        '\u{0476}'..='\u{0477}' => No,
-        '\u{04C1}'..='\u{04C2}' => No,
-        '\u{04D0}'..='\u{04D3}' => No,
-        '\u{04D6}'..='\u{04D7}' => No,
-        '\u{04DA}'..='\u{04DF}' => No,
-        '\u{04E2}'..='\u{04E7}' => No,
-        '\u{04EA}'..='\u{04F5}' => No,
-        '\u{04F8}'..='\u{04F9}' => No,
-        '\u{0587}' => No,
-        '\u{0622}'..='\u{0626}' => No,
-        '\u{0675}'..='\u{0678}' => No,
-        '\u{06C0}' => No,
-        '\u{06C2}' => No,
-        '\u{06D3}' => No,
-        '\u{0929}' => No,
-        '\u{0931}' => No,
-        '\u{0934}' => No,
-        '\u{0958}'..='\u{095F}' => No,
-        '\u{09CB}'..='\u{09CC}' => No,
-        '\u{09DC}'..='\u{09DD}' => No,
-        '\u{09DF}' => No,
-        '\u{0A33}' => No,
-        '\u{0A36}' => No,
-        '\u{0A59}'..='\u{0A5B}' => No,
-        '\u{0A5E}' => No,
-        '\u{0B48}' => No,
-        '\u{0B4B}'..='\u{0B4C}' => No,
-        '\u{0B5C}'..='\u{0B5D}' => No,
-        '\u{0B94}' => No,
-        '\u{0BCA}'..='\u{0BCC}' => No,
-        '\u{0C48}' => No,
-        '\u{0CC0}' => No,
-        '\u{0CC7}'..='\u{0CC8}' => No,
-        '\u{0CCA}'..='\u{0CCB}' => No,
-        '\u{0D4A}'..='\u{0D4C}' => No,
-        '\u{0DDA}' => No,
-        '\u{0DDC}'..='\u{0DDE}' => No,
-        '\u{0E33}' => No,
-        '\u{0EB3}' => No,
-        '\u{0EDC}'..='\u{0EDD}' => No,
-        '\u{0F0C}' => No,
-        '\u{0F43}' => No,
-        '\u{0F4D}' => No,
-        '\u{0F52}' => No,
-        '\u{0F57}' => No,
-        '\u{0F5C}' => No,
-        '\u{0F69}' => No,
-        '\u{0F73}' => No,
-        '\u{0F75}'..='\u{0F79}' => No,
-        '\u{0F81}' => No,
-        '\u{0F93}' => No,
-        '\u{0F9D}' => No,
-        '\u{0FA2}' => No,
-        '\u{0FA7}' => No,
-        '\u{0FAC}' => No,
-        '\u{0FB9}' => No,
-        '\u{1026}' => No,
-        '\u{10FC}' => No,
-        '\u{1B06}' => No,
-        '\u{1B08}' => No,
-        '\u{1B0A}' => No,
-        '\u{1B0C}' => No,
-        '\u{1B0E}' => No,
-        '\u{1B12}' => No,
-        '\u{1B3B}' => No,
-        '\u{1B3D}' => No,
-        '\u{1B40}'..='\u{1B41}' => No,
-        '\u{1B43}' => No,
-        '\u{1D2C}'..='\u{1D2E}' => No,
-        '\u{1D30}'..='\u{1D3A}' => No,
-        '\u{1D3C}'..='\u{1D4D}' => No,
-        '\u{1D4F}'..='\u{1D6A}' => No,
-        '\u{1D78}' => No,
-        '\u{1D9B}'..='\u{1DBF}' => No,
-        '\u{1E00}'..='\u{1E9B}' => No,
-        '\u{1EA0}'..='\u{1EF9}' => No,
-        '\u{1F00}'..='\u{1F15}' => No,
-        '\u{1F18}'..='\u{1F1D}' => No,
-        '\u{1F20}'..='\u{1F45}' => No,
-        '\u{1F48}'..='\u{1F4D}' => No,
-        '\u{1F50}'..='\u{1F57}' => No,
-        '\u{1F59}' => No,
-        '\u{1F5B}' => No,
-        '\u{1F5D}' => No,
-        '\u{1F5F}'..='\u{1F7D}' => No,
-        '\u{1F80}'..='\u{1FB4}' => No,
-        '\u{1FB6}'..='\u{1FBC}' => No,
-        '\u{1FBD}' => No,
-        '\u{1FBE}' => No,
-        '\u{1FBF}'..='\u{1FC1}' => No,
-        '\u{1FC2}'..='\u{1FC4}' => No,
-        '\u{1FC6}'..='\u{1FCC}' => No,
-        '\u{1FCD}'..='\u{1FCF}' => No,
-        '\u{1FD0}'..='\u{1FD3}' => No,
-        '\u{1FD6}'..='\u{1FDB}' => No,
-        '\u{1FDD}'..='\u{1FDF}' => No,
-        '\u{1FE0}'..='\u{1FEC}' => No,
-        '\u{1FED}'..='\u{1FEF}' => No,
-        '\u{1FF2}'..='\u{1FF4}' => No,
-        '\u{1FF6}'..='\u{1FFC}' => No,
-        '\u{1FFD}'..='\u{1FFE}' => No,
-        '\u{2000}'..='\u{200A}' => No,
-        '\u{2011}' => No,
-        '\u{2017}' => No,
-        '\u{2024}'..='\u{2026}' => No,
-        '\u{202F}' => No,
-        '\u{2033}'..='\u{2034}' => No,
-        '\u{2036}'..='\u{2037}' => No,
-        '\u{203C}' => No,
-        '\u{203E}' => No,
-        '\u{2047}'..='\u{2049}' => No,
-        '\u{2057}' => No,
-        '\u{205F}' => No,
-        '\u{2070}' => No,
-        '\u{2071}' => No,
-        '\u{2074}'..='\u{2079}' => No,
-        '\u{207A}'..='\u{207C}' => No,
-        '\u{207D}' => No,
-        '\u{207E}' => No,
-        '\u{207F}' => No,
-        '\u{2080}'..='\u{2089}' => No,
-        '\u{208A}'..='\u{208C}' => No,
-        '\u{208D}' => No,
-        '\u{208E}' => No,
-        '\u{2090}'..='\u{209C}' => No,
-        '\u{20A8}' => No,
-        '\u{2100}'..='\u{2101}' => No,
-        '\u{2102}' => No,
-        '\u{2103}' => No,
-        '\u{2105}'..='\u{2106}' => No,
-        '\u{2107}' => No,
-        '\u{2109}' => No,
-        '\u{210A}'..='\u{2113}' => No,
-        '\u{2115}' => No,
-        '\u{2116}' => No,
-        '\u{2119}'..='\u{211D}' => No,
-        '\u{2120}'..='\u{2122}' => No,
-        '\u{2124}' => No,
-        '\u{2126}' => No,
-        '\u{2128}' => No,
-        '\u{212A}'..='\u{212D}' => No,
-        '\u{212F}'..='\u{2131}' => No,
-        '\u{2133}'..='\u{2134}' => No,
-        '\u{2135}'..='\u{2138}' => No,
-        '\u{2139}' => No,
-        '\u{213B}' => No,
-        '\u{213C}'..='\u{213F}' => No,
-        '\u{2140}' => No,
-        '\u{2145}'..='\u{2149}' => No,
-        '\u{2150}'..='\u{215F}' => No,
-        '\u{2160}'..='\u{217F}' => No,
-        '\u{2189}' => No,
-        '\u{219A}'..='\u{219B}' => No,
-        '\u{21AE}' => No,
-        '\u{21CD}' => No,
-        '\u{21CE}'..='\u{21CF}' => No,
-        '\u{2204}' => No,
-        '\u{2209}' => No,
-        '\u{220C}' => No,
-        '\u{2224}' => No,
-        '\u{2226}' => No,
-        '\u{222C}'..='\u{222D}' => No,
-        '\u{222F}'..='\u{2230}' => No,
-        '\u{2241}' => No,
-        '\u{2244}' => No,
-        '\u{2247}' => No,
-        '\u{2249}' => No,
-        '\u{2260}' => No,
-        '\u{2262}' => No,
-        '\u{226D}'..='\u{2271}' => No,
-        '\u{2274}'..='\u{2275}' => No,
-        '\u{2278}'..='\u{2279}' => No,
-        '\u{2280}'..='\u{2281}' => No,
-        '\u{2284}'..='\u{2285}' => No,
-        '\u{2288}'..='\u{2289}' => No,
-        '\u{22AC}'..='\u{22AF}' => No,
-        '\u{22E0}'..='\u{22E3}' => No,
-        '\u{22EA}'..='\u{22ED}' => No,
-        '\u{2329}' => No,
-        '\u{232A}' => No,
-        '\u{2460}'..='\u{249B}' => No,
-        '\u{249C}'..='\u{24E9}' => No,
-        '\u{24EA}' => No,
-        '\u{2A0C}' => No,
-        '\u{2A74}'..='\u{2A76}' => No,
-        '\u{2ADC}' => No,
-        '\u{2C7C}'..='\u{2C7D}' => No,
-        '\u{2D6F}' => No,
-        '\u{2E9F}' => No,
-        '\u{2EF3}' => No,
-        '\u{2F00}'..='\u{2FD5}' => No,
-        '\u{3000}' => No,
-        '\u{3036}' => No,
-        '\u{3038}'..='\u{303A}' => No,
-        '\u{304C}' => No,
-        '\u{304E}' => No,
-        '\u{3050}' => No,
-        '\u{3052}' => No,
-        '\u{3054}' => No,
-        '\u{3056}' => No,
-        '\u{3058}' => No,
-        '\u{305A}' => No,
-        '\u{305C}' => No,
-        '\u{305E}' => No,
-        '\u{3060}' => No,
-        '\u{3062}' => No,
-        '\u{3065}' => No,
-        '\u{3067}' => No,
-        '\u{3069}' => No,
-        '\u{3070}'..='\u{3071}' => No,
-        '\u{3073}'..='\u{3074}' => No,
-        '\u{3076}'..='\u{3077}' => No,
-        '\u{3079}'..='\u{307A}' => No,
-        '\u{307C}'..='\u{307D}' => No,
-        '\u{3094}' => No,
-        '\u{309B}'..='\u{309C}' => No,
-        '\u{309E}' => No,
-        '\u{309F}' => No,
-        '\u{30AC}' => No,
-        '\u{30AE}' => No,
-        '\u{30B0}' => No,
-        '\u{30B2}' => No,
-        '\u{30B4}' => No,
-        '\u{30B6}' => No,
-        '\u{30B8}' => No,
-        '\u{30BA}' => No,
-        '\u{30BC}' => No,
-        '\u{30BE}' => No,
-        '\u{30C0}' => No,
-        '\u{30C2}' => No,
-        '\u{30C5}' => No,
-        '\u{30C7}' => No,
-        '\u{30C9}' => No,
-        '\u{30D0}'..='\u{30D1}' => No,
-        '\u{30D3}'..='\u{30D4}' => No,
-        '\u{30D6}'..='\u{30D7}' => No,
-        '\u{30D9}'..='\u{30DA}' => No,
-        '\u{30DC}'..='\u{30DD}' => No,
-        '\u{30F4}' => No,
-        '\u{30F7}'..='\u{30FA}' => No,
-        '\u{30FE}' => No,
-        '\u{30FF}' => No,
-        '\u{3131}'..='\u{318E}' => No,
-        '\u{3192}'..='\u{3195}' => No,
-        '\u{3196}'..='\u{319F}' => No,
-        '\u{3200}'..='\u{321E}' => No,
-        '\u{3220}'..='\u{3229}' => No,
-        '\u{322A}'..='\u{3247}' => No,
-        '\u{3250}' => No,
-        '\u{3251}'..='\u{325F}' => No,
-        '\u{3260}'..='\u{327E}' => No,
-        '\u{3280}'..='\u{3289}' => No,
-        '\u{328A}'..='\u{32B0}' => No,
-        '\u{32B1}'..='\u{32BF}' => No,
-        '\u{32C0}'..='\u{33FF}' => No,
-        '\u{A69C}'..='\u{A69D}' => No,
-        '\u{A770}' => No,
-        '\u{A7F2}'..='\u{A7F4}' => No,
-        '\u{A7F8}'..='\u{A7F9}' => No,
-        '\u{AB5C}'..='\u{AB5F}' => No,
-        '\u{AB69}' => No,
-        '\u{AC00}'..='\u{D7A3}' => No,
-        '\u{F900}'..='\u{FA0D}' => No,
-        '\u{FA10}' => No,
-        '\u{FA12}' => No,
-        '\u{FA15}'..='\u{FA1E}' => No,
-        '\u{FA20}' => No,
-        '\u{FA22}' => No,
-        '\u{FA25}'..='\u{FA26}' => No,
-        '\u{FA2A}'..='\u{FA6D}' => No,
-        '\u{FA70}'..='\u{FAD9}' => No,
-        '\u{FB00}'..='\u{FB06}' => No,
-        '\u{FB13}'..='\u{FB17}' => No,
-        '\u{FB1D}' => No,
-        '\u{FB1F}'..='\u{FB28}' => No,
-        '\u{FB29}' => No,
-        '\u{FB2A}'..='\u{FB36}' => No,
-        '\u{FB38}'..='\u{FB3C}' => No,
-        '\u{FB3E}' => No,
-        '\u{FB40}'..='\u{FB41}' => No,
-        '\u{FB43}'..='\u{FB44}' => No,
-        '\u{FB46}'..='\u{FBB1}' => No,
-        '\u{FBD3}'..='\u{FD3D}' => No,
-        '\u{FD50}'..='\u{FD8F}' => No,
-        '\u{FD92}'..='\u{FDC7}' => No,
-        '\u{FDF0}'..='\u{FDFB}' => No,
-        '\u{FDFC}' => No,
-        '\u{FE10}'..='\u{FE16}' => No,
-        '\u{FE17}' => No,
-        '\u{FE18}' => No,
-        '\u{FE19}' => No,
-        '\u{FE30}' => No,
-        '\u{FE31}'..='\u{FE32}' => No,
-        '\u{FE33}'..='\u{FE34}' => No,
-        '\u{FE35}' => No,
-        '\u{FE36}' => No,
-        '\u{FE37}' => No,
-        '\u{FE38}' => No,
-        '\u{FE39}' => No,
-        '\u{FE3A}' => No,
-        '\u{FE3B}' => No,
-        '\u{FE3C}' => No,
-        '\u{FE3D}' => No,
-        '\u{FE3E}' => No,
-        '\u{FE3F}' => No,
-        '\u{FE40}' => No,
-        '\u{FE41}' => No,
-        '\u{FE42}' => No,
-        '\u{FE43}' => No,
-        '\u{FE44}' => No,
-        '\u{FE47}' => No,
-        '\u{FE48}' => No,
-        '\u{FE49}'..='\u{FE4C}' => No,
-        '\u{FE4D}'..='\u{FE4F}' => No,
-        '\u{FE50}'..='\u{FE52}' => No,
-        '\u{FE54}'..='\u{FE57}' => No,
-        '\u{FE58}' => No,
-        '\u{FE59}' => No,
-        '\u{FE5A}' => No,
-        '\u{FE5B}' => No,
-        '\u{FE5C}' => No,
-        '\u{FE5D}' => No,
-        '\u{FE5E}' => No,
-        '\u{FE5F}'..='\u{FE61}' => No,
-        '\u{FE62}' => No,
-        '\u{FE63}' => No,
-        '\u{FE64}'..='\u{FE66}' => No,
-        '\u{FE68}' => No,
-        '\u{FE69}' => No,
-        '\u{FE6A}'..='\u{FE6B}' => No,
-        '\u{FE70}'..='\u{FE72}' => No,
-        '\u{FE74}' => No,
-        '\u{FE76}'..='\u{FEFC}' => No,
-        '\u{FF01}'..='\u{FF03}' => No,
-        '\u{FF04}' => No,
-        '\u{FF05}'..='\u{FF07}' => No,
-        '\u{FF08}' => No,
-        '\u{FF09}' => No,
-        '\u{FF0A}' => No,
-        '\u{FF0B}' => No,
-        '\u{FF0C}' => No,
-        '\u{FF0D}' => No,
-        '\u{FF0E}'..='\u{FF0F}' => No,
-        '\u{FF10}'..='\u{FF19}' => No,
-        '\u{FF1A}'..='\u{FF1B}' => No,
-        '\u{FF1C}'..='\u{FF1E}' => No,
-        '\u{FF1F}'..='\u{FF20}' => No,
-        '\u{FF21}'..='\u{FF3A}' => No,
-        '\u{FF3B}' => No,
-        '\u{FF3C}' => No,
-        '\u{FF3D}' => No,
-        '\u{FF3E}' => No,
-        '\u{FF3F}' => No,
-        '\u{FF40}' => No,
-        '\u{FF41}'..='\u{FF5A}' => No,
-        '\u{FF5B}' => No,
-        '\u{FF5C}' => No,
-        '\u{FF5D}' => No,
-        '\u{FF5E}' => No,
-        '\u{FF5F}' => No,
-        '\u{FF60}' => No,
-        '\u{FF61}' => No,
-        '\u{FF62}' => No,
-        '\u{FF63}' => No,
-        '\u{FF64}'..='\u{FF65}' => No,
-        '\u{FF66}'..='\u{FF6F}' => No,
-        '\u{FF70}' => No,
-        '\u{FF71}'..='\u{FF9D}' => No,
-        '\u{FF9E}'..='\u{FF9F}' => No,
-        '\u{FFA0}'..='\u{FFBE}' => No,
-        '\u{FFC2}'..='\u{FFC7}' => No,
-        '\u{FFCA}'..='\u{FFCF}' => No,
-        '\u{FFD2}'..='\u{FFD7}' => No,
-        '\u{FFDA}'..='\u{FFDC}' => No,
-        '\u{FFE0}'..='\u{FFE1}' => No,
-        '\u{FFE2}' => No,
-        '\u{FFE3}' => No,
-        '\u{FFE4}' => No,
-        '\u{FFE5}'..='\u{FFE6}' => No,
-        '\u{FFE8}' => No,
-        '\u{FFE9}'..='\u{FFEC}' => No,
-        '\u{FFED}'..='\u{FFEE}' => No,
-        '\u{105C9}' => No,
-        '\u{105E4}' => No,
-        '\u{10781}'..='\u{10785}' => No,
-        '\u{10787}'..='\u{107B0}' => No,
-        '\u{107B2}'..='\u{107BA}' => No,
-        '\u{1109A}' => No,
-        '\u{1109C}' => No,
-        '\u{110AB}' => No,
-        '\u{1112E}'..='\u{1112F}' => No,
-        '\u{1134B}'..='\u{1134C}' => No,
-        '\u{11383}' => No,
-        '\u{11385}' => No,
-        '\u{1138E}' => No,
-        '\u{11391}' => No,
-        '\u{113C5}' => No,
-        '\u{113C7}'..='\u{113C8}' => No,
-        '\u{114BB}'..='\u{114BC}' => No,
-        '\u{114BE}' => No,
-        '\u{115BA}'..='\u{115BB}' => No,
-        '\u{11938}' => No,
-        '\u{16121}'..='\u{16128}' => No,
-        '\u{16D68}'..='\u{16D6A}' => No,
-        '\u{1CCD6}'..='\u{1CCEF}' => No,
-        '\u{1CCF0}'..='\u{1CCF9}' => No,
-        '\u{1D15E}'..='\u{1D164}' => No,
-        '\u{1D1BB}'..='\u{1D1C0}' => No,
-        '\u{1D400}'..='\u{1D454}' => No,
-        '\u{1D456}'..='\u{1D49C}' => No,
-        '\u{1D49E}'..='\u{1D49F}' => No,
-        '\u{1D4A2}' => No,
-        '\u{1D4A5}'..='\u{1D4A6}' => No,
-        '\u{1D4A9}'..='\u{1D4AC}' => No,
-        '\u{1D4AE}'..='\u{1D4B9}' => No,
-        '\u{1D4BB}' => No,
-        '\u{1D4BD}'..='\u{1D4C3}' => No,
-        '\u{1D4C5}'..='\u{1D505}' => No,
-        '\u{1D507}'..='\u{1D50A}' => No,
-        '\u{1D50D}'..='\u{1D514}' => No,
-        '\u{1D516}'..='\u{1D51C}' => No,
-        '\u{1D51E}'..='\u{1D539}' => No,
-        '\u{1D53B}'..='\u{1D53E}' => No,
-        '\u{1D540}'..='\u{1D544}' => No,
-        '\u{1D546}' => No,
-        '\u{1D54A}'..='\u{1D550}' => No,
-        '\u{1D552}'..='\u{1D6A5}' => No,
-        '\u{1D6A8}'..='\u{1D6C0}' => No,
-        '\u{1D6C1}' => No,
-        '\u{1D6C2}'..='\u{1D6DA}' => No,
-        '\u{1D6DB}' => No,
-        '\u{1D6DC}'..='\u{1D6FA}' => No,
-        '\u{1D6FB}' => No,
-        '\u{1D6FC}'..='\u{1D714}' => No,
-        '\u{1D715}' => No,
-        '\u{1D716}'..='\u{1D734}' => No,
-        '\u{1D735}' => No,
-        '\u{1D736}'..='\u{1D74E}' => No,
-        '\u{1D74F}' => No,
-        '\u{1D750}'..='\u{1D76E}' => No,
-        '\u{1D76F}' => No,
-        '\u{1D770}'..='\u{1D788}' => No,
-        '\u{1D789}' => No,
-        '\u{1D78A}'..='\u{1D7A8}' => No,
-        '\u{1D7A9}' => No,
-        '\u{1D7AA}'..='\u{1D7C2}' => No,
-        '\u{1D7C3}' => No,
-        '\u{1D7C4}'..='\u{1D7CB}' => No,
-        '\u{1D7CE}'..='\u{1D7FF}' => No,
-        '\u{1E030}'..='\u{1E06D}' => No,
-        '\u{1EE00}'..='\u{1EE03}' => No,
-        '\u{1EE05}'..='\u{1EE1F}' => No,
-        '\u{1EE21}'..='\u{1EE22}' => No,
-        '\u{1EE24}' => No,
-        '\u{1EE27}' => No,
-        '\u{1EE29}'..='\u{1EE32}' => No,
-        '\u{1EE34}'..='\u{1EE37}' => No,
-        '\u{1EE39}' => No,
-        '\u{1EE3B}' => No,
-        '\u{1EE42}' => No,
-        '\u{1EE47}' => No,
-        '\u{1EE49}' => No,
-        '\u{1EE4B}' => No,
-        '\u{1EE4D}'..='\u{1EE4F}' => No,
-        '\u{1EE51}'..='\u{1EE52}' => No,
-        '\u{1EE54}' => No,
-        '\u{1EE57}' => No,
-        '\u{1EE59}' => No,
-        '\u{1EE5B}' => No,
-        '\u{1EE5D}' => No,
-        '\u{1EE5F}' => No,
-        '\u{1EE61}'..='\u{1EE62}' => No,
-        '\u{1EE64}' => No,
-        '\u{1EE67}'..='\u{1EE6A}' => No,
-        '\u{1EE6C}'..='\u{1EE72}' => No,
-        '\u{1EE74}'..='\u{1EE77}' => No,
-        '\u{1EE79}'..='\u{1EE7C}' => No,
-        '\u{1EE7E}' => No,
-        '\u{1EE80}'..='\u{1EE89}' => No,
-        '\u{1EE8B}'..='\u{1EE9B}' => No,
-        '\u{1EEA1}'..='\u{1EEA3}' => No,
-        '\u{1EEA5}'..='\u{1EEA9}' => No,
-        '\u{1EEAB}'..='\u{1EEBB}' => No,
-        '\u{1F100}'..='\u{1F10A}' => No,
-        '\u{1F110}'..='\u{1F12E}' => No,
-        '\u{1F130}'..='\u{1F14F}' => No,
-        '\u{1F16A}'..='\u{1F16C}' => No,
-        '\u{1F190}' => No,
-        '\u{1F200}'..='\u{1F202}' => No,
-        '\u{1F210}'..='\u{1F23B}' => No,
-        '\u{1F240}'..='\u{1F248}' => No,
-        '\u{1F250}'..='\u{1F251}' => No,
-        '\u{1FBF0}'..='\u{1FBF9}' => No,
-        '\u{2F800}'..='\u{2FA1D}' => No,
-        _ => Yes,
-    }
-}
-#[inline]
-pub fn stream_safe_leading_nonstarters(c: char) -> usize {
-    match c {
-        '\u{0340}' => 1,
-        '\u{0341}' => 1,
-        '\u{0343}' => 1,
-        '\u{0344}' => 2,
-        '\u{0F73}' => 2,
-        '\u{0F75}' => 2,
-        '\u{0F81}' => 2,
-        '\u{FF9E}' => 1,
-        '\u{FF9F}' => 1,
-        _ => 0,
-    }
-}
-
-pub(crate) const TRAILING_NONSTARTERS_SALT: &[u16] = &[
-    0x4B0, 0x000, 0x012, 0x151, 0x000, 0x051, 0x000, 0x166, 0x00E, 0x000, 0x000, 0x00A, 0x004,
-    0x008, 0x000, 0x012, 0x002, 0x000, 0x002, 0x000, 0x00E, 0x000, 0x000, 0x127, 0x000, 0x000,
-    0x000, 0x004, 0x18C, 0x019, 0x000, 0x000, 0x001, 0x005, 0x000, 0x06A, 0x001, 0x0C5, 0x010,
-    0x000, 0x000, 0x002, 0x003, 0x011, 0x002, 0x000, 0x000, 0x003, 0x008, 0x026, 0x104, 0x0BC,
-    0x033, 0x043, 0x033, 0x00E, 0x000, 0x000, 0x02D, 0x020, 0x000, 0x00D, 0x002, 0x000, 0x027,
-    0x000, 0x023, 0x038, 0x008, 0x00D, 0x060, 0x026, 0x000, 0x01B, 0x000, 0x000, 0x05A, 0x002,
-    0x000, 0x007, 0x048, 0x00F, 0x003, 0x001, 0x00F, 0x04A, 0x002, 0x003, 0x000, 0x003, 0x004,
-    0x002, 0x037, 0x00C, 0x001, 0x044, 0x000, 0x000, 0x006, 0x012, 0x000, 0x001, 0x001, 0x000,
-    0x035, 0x00C, 0x00B, 0x000, 0x000, 0x001, 0x000, 0x000, 0x000, 0x00B, 0x000, 0x005, 0x00F,
-    0x000, 0x000, 0x00F, 0x012, 0x000, 0x00B, 0x009, 0x001, 0x001, 0x016, 0x000, 0x000, 0x000,
-    0x003, 0x02C, 0x007, 0x00C, 0x002, 0x001, 0x003, 0x002, 0x008, 0x00C, 0x002, 0x01B, 0x004,
-    0x002, 0x002, 0x001, 0x005, 0x001, 0x000, 0x000, 0x015, 0x000, 0x000, 0x00D, 0x008, 0x000,
-    0x000, 0x005, 0x026, 0x008, 0x000, 0x000, 0x000, 0x000, 0x013, 0x001, 0x001, 0x000, 0x032,
-    0x000, 0x003, 0x00B, 0x006, 0x002, 0x000, 0x000, 0x000, 0x002, 0x003, 0x001, 0x002, 0x000,
-    0x033, 0x000, 0x002, 0x004, 0x01D, 0x000, 0x001, 0x003, 0x000, 0x000, 0x000, 0x030, 0x00C,
-    0x006, 0x000, 0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x005, 0x000, 0x002, 0x001, 0x002,
-    0x003, 0x00D, 0x008, 0x000, 0x003, 0x001, 0x000, 0x002, 0x000, 0x000, 0x000, 0x001, 0x008,
-    0x000, 0x007, 0x000, 0x000, 0x000, 0x00A, 0x000, 0x003, 0x000, 0x019, 0x000, 0x006, 0x007,
-    0x007, 0x005, 0x001, 0x001, 0x001, 0x001, 0x000, 0x004, 0x003, 0x006, 0x00A, 0x000, 0x000,
-    0x000, 0x000, 0x001, 0x001, 0x000, 0x003, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x003,
-    0x00A, 0x012, 0x000, 0x000, 0x001, 0x000, 0x009, 0x002, 0x003, 0x001, 0x007, 0x000, 0x000,
-    0x005, 0x005, 0x000, 0x002, 0x00C, 0x008, 0x016, 0x003, 0x000, 0x000, 0x000, 0x000, 0x007,
-    0x009, 0x001, 0x000, 0x000, 0x00A, 0x000, 0x002, 0x000, 0x014, 0x000, 0x002, 0x001, 0x007,
-    0x000, 0x004, 0x000, 0x000, 0x000, 0x004, 0x010, 0x002, 0x001, 0x00A, 0x00C, 0x004, 0x000,
-    0x003, 0x000, 0x001, 0x00B, 0x000, 0x005, 0x001, 0x00B, 0x000, 0x005, 0x007, 0x005, 0x000,
-    0x002, 0x008, 0x002, 0x000, 0x005, 0x006, 0x000, 0x000, 0x000, 0x001, 0x000, 0x006, 0x00C,
-    0x021, 0x005, 0x004, 0x000, 0x003, 0x000, 0x000, 0x006, 0x003, 0x000, 0x00B, 0x000, 0x002,
-    0x001, 0x000, 0x002, 0x000, 0x000, 0x007, 0x000, 0x001, 0x000, 0x006, 0x000, 0x000, 0x000,
-    0x002, 0x004, 0x013, 0x000, 0x013, 0x001, 0x000, 0x007, 0x002, 0x005, 0x000, 0x000, 0x00A,
-    0x001, 0x010, 0x009, 0x000, 0x001, 0x003, 0x001, 0x000, 0x000, 0x000, 0x001, 0x000, 0x00C,
-    0x001, 0x003, 0x000, 0x009, 0x00E, 0x003, 0x006, 0x001, 0x003, 0x003, 0x000, 0x002, 0x003,
-    0x004, 0x000, 0x00C, 0x002, 0x004, 0x010, 0x002, 0x005, 0x001, 0x000, 0x000, 0x004, 0x000,
-    0x006, 0x000, 0x000, 0x006, 0x000, 0x000, 0x00C, 0x000, 0x002, 0x000, 0x000, 0x003, 0x000,
-    0x004, 0x002, 0x003, 0x001, 0x001, 0x000, 0x001, 0x000, 0x002, 0x001, 0x001, 0x001, 0x000,
-    0x001, 0x000, 0x000, 0x003, 0x000, 0x000, 0x004, 0x004, 0x003, 0x000, 0x003, 0x000, 0x000,
-    0x010, 0x000, 0x000, 0x001, 0x006, 0x001, 0x003, 0x000, 0x004, 0x001, 0x000, 0x00F, 0x002,
-    0x007, 0x001, 0x000, 0x000, 0x006, 0x003, 0x002, 0x000, 0x014, 0x002, 0x02B, 0x000, 0x000,
-    0x00E, 0x000, 0x003, 0x000, 0x000, 0x00C, 0x000, 0x006, 0x004, 0x010, 0x007, 0x002, 0x006,
-    0x00D, 0x000, 0x003, 0x001, 0x00C, 0x004, 0x001, 0x000, 0x005, 0x002, 0x000, 0x001, 0x00B,
-    0x001, 0x001, 0x000, 0x001, 0x000, 0x000, 0x012, 0x000, 0x000, 0x007, 0x000, 0x000, 0x001,
-    0x000, 0x004, 0x005, 0x004, 0x000, 0x001, 0x000, 0x002, 0x00C, 0x005, 0x00C, 0x001, 0x007,
-    0x001, 0x003, 0x000, 0x005, 0x004, 0x001, 0x000, 0x000, 0x004, 0x000, 0x001, 0x005, 0x004,
-    0x001, 0x000, 0x00A, 0x002, 0x001, 0x001, 0x000, 0x001, 0x001, 0x007, 0x000, 0x004, 0x001,
-    0x006, 0x005, 0x003, 0x002, 0x001, 0x001, 0x003, 0x000, 0x004, 0x000, 0x005, 0x004, 0x000,
-    0x006, 0x002, 0x000, 0x000, 0x007, 0x004, 0x002, 0x000, 0x000, 0x008, 0x000, 0x003, 0x002,
-    0x007, 0x002, 0x003, 0x000, 0x000, 0x000, 0x002, 0x003, 0x003, 0x001, 0x000, 0x000, 0x004,
-    0x002, 0x003, 0x002, 0x000, 0x000, 0x005, 0x000, 0x001, 0x000, 0x001, 0x000, 0x006, 0x002,
-    0x001, 0x003, 0x001, 0x001, 0x000, 0x007, 0x001, 0x000, 0x005, 0x000, 0x001, 0x002, 0x000,
-    0x004, 0x000, 0x001, 0x000, 0x004, 0x002, 0x003, 0x002, 0x001, 0x001, 0x003, 0x000, 0x000,
-    0x000, 0x003, 0x000, 0x007, 0x002, 0x000, 0x008, 0x004, 0x001, 0x000, 0x001, 0x003, 0x000,
-    0x000, 0x00A, 0x000, 0x000, 0x01D, 0x002, 0x000, 0x000, 0x011, 0x000, 0x001, 0x001, 0x003,
-    0x000, 0x007, 0x001, 0x000, 0x001, 0x000, 0x002, 0x00B, 0x000, 0x002, 0x003, 0x003, 0x004,
-    0x00D, 0x000, 0x001, 0x00A, 0x000, 0x002, 0x008, 0x001, 0x005, 0x001, 0x005, 0x001, 0x000,
-    0x003, 0x005, 0x000, 0x002, 0x000, 0x000, 0x000, 0x003, 0x003, 0x001, 0x001, 0x000, 0x000,
-    0x000, 0x000, 0x001, 0x000, 0x000, 0x001, 0x000, 0x000, 0x011, 0x001, 0x000, 0x003, 0x001,
-    0x002, 0x004, 0x000, 0x004, 0x000, 0x000, 0x00A, 0x000, 0x001, 0x000, 0x001, 0x001, 0x002,
-    0x001, 0x000, 0x00C, 0x000, 0x000, 0x001, 0x000, 0x000, 0x002, 0x004, 0x000, 0x000, 0x000,
-    0x000, 0x003, 0x005, 0x001, 0x004, 0x000, 0x002, 0x005, 0x001, 0x003, 0x005, 0x001, 0x001,
-    0x001, 0x00F, 0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x002, 0x003, 0x003, 0x000, 0x005,
-    0x003, 0x000, 0x000, 0x000, 0x00A, 0x000, 0x002, 0x003, 0x000, 0x001, 0x006, 0x000, 0x004,
-    0x004, 0x000, 0x001, 0x002, 0x000, 0x003, 0x001, 0x000, 0x001, 0x003, 0x003, 0x003, 0x002,
-    0x001, 0x007, 0x002, 0x002, 0x003, 0x000, 0x003, 0x001, 0x000, 0x000, 0x001, 0x000, 0x000,
-    0x000, 0x000, 0x000, 0x006, 0x000, 0x001, 0x005, 0x002, 0x003, 0x003, 0x008, 0x000, 0x000,
-    0x000, 0x002, 0x004, 0x001, 0x000, 0x003, 0x002, 0x006, 0x000, 0x00B, 0x002, 0x001, 0x000,
-    0x001, 0x000, 0x001, 0x008, 0x004, 0x006, 0x001, 0x000, 0x000, 0x002, 0x009, 0x001, 0x005,
-    0x003, 0x002, 0x000, 0x001, 0x001, 0x009, 0x001, 0x007, 0x001, 0x000, 0x001, 0x000, 0x001,
-    0x000, 0x002, 0x007, 0x001, 0x002, 0x002, 0x003, 0x001, 0x000, 0x00A, 0x004, 0x000, 0x001,
-    0x002, 0x001, 0x005, 0x000, 0x00B, 0x001, 0x000, 0x001, 0x002, 0x000, 0x001, 0x007, 0x000,
-    0x001, 0x001, 0x001, 0x005, 0x003, 0x001, 0x000, 0x000, 0x001, 0x000, 0x001, 0x000, 0x000,
-    0x000, 0x000, 0x003, 0x003, 0x000, 0x000, 0x001, 0x007, 0x001, 0x004, 0x001, 0x002, 0x001,
-    0x000, 0x008, 0x000, 0x003, 0x000, 0x003, 0x004, 0x006, 0x002, 0x001, 0x000, 0x000, 0x000,
-    0x001, 0x003, 0x003, 0x003, 0x005, 0x000, 0x002, 0x003, 0x003, 0x003, 0x001, 0x003, 0x003,
-    0x001, 0x002, 0x000, 0x002, 0x000, 0x000, 0x000, 0x001, 0x001, 0x000, 0x001, 0x006, 0x002,
-    0x001, 0x000, 0x000, 0x003, 0x001, 0x002, 0x008, 0x001, 0x002, 0x000, 0x000, 0x000, 0x002,
-    0x000, 0x001, 0x001, 0x001, 0x001, 0x000, 0x002, 0x002, 0x003, 0x003, 0x003, 0x000, 0x003,
-    0x001, 0x001, 0x006, 0x000, 0x000, 0x002, 0x002, 0x001, 0x001, 0x001, 0x005, 0x000, 0x003,
-    0x002, 0x000, 0x004, 0x008, 0x000, 0x000, 0x001, 0x002, 0x000, 0x000, 0x004, 0x001, 0x002,
-    0x000, 0x000, 0x001, 0x000, 0x001, 0x001, 0x001, 0x001, 0x000, 0x002, 0x001, 0x000, 0x001,
-    0x000, 0x000, 0x001, 0x000, 0x004, 0x002, 0x000, 0x000, 0x002, 0x001, 0x003, 0x000, 0x000,
-    0x000, 0x001, 0x003, 0x003, 0x000, 0x003, 0x004, 0x002, 0x002, 0x000, 0x000, 0x001, 0x001,
-    0x000, 0x006, 0x000, 0x002, 0x000, 0x00C, 0x001, 0x001, 0x002, 0x001, 0x000, 0x002, 0x001,
-    0x001, 0x000, 0x000, 0x002, 0x000, 0x000, 0x000, 0x000, 0x000, 0x001, 0x000, 0x000, 0x005,
-    0x001, 0x000, 0x005, 0x000, 0x000, 0x003, 0x001, 0x000, 0x000, 0x001, 0x000, 0x000, 0x005,
-    0x001, 0x001, 0x000, 0x001, 0x001, 0x007, 0x003, 0x002, 0x004, 0x000, 0x003, 0x002, 0x001,
-];
-pub(crate) const TRAILING_NONSTARTERS_KV: &[u32] = &[
-    0x030D401, 0x01F2E02, 0x01F1D02, 0x0227801, 0x0224901, 0x000E101, 0x01FFE01, 0x001A001,
-    0x01F0A02, 0x0022901, 0x0307401, 0x01F6C02, 0x01E7601, 0x030B001, 0x004D001, 0x0FB3801,
-    0x01EA902, 0x0FEF901, 0x0038F01, 0x01F3101, 0x0011701, 0x0034301, 0x0226201, 0x01FF801,
-    0x00F7302, 0x0FE8B01, 0x0307601, 0x003AE01, 0x01FC202, 0x0FC6002, 0x0224101, 0x0012B01,
-    0x01F0402, 0x0220401, 0x003B002, 0x01F9A03, 0x01EB702, 0x01E9301, 0x00A5B01, 0x01F5602,
-    0x0021B01, 0x1D1C002, 0x1D16102, 0x0016E01, 0x01FD202, 0x01EEF02, 0x030AC01, 0x01F3502,
-    0x01FE101, 0x01E6802, 0x004E701, 0x0010801, 0x0309E01, 0x01F3302, 0x01EC901, 0x001FA02,
-    0x01E7B02, 0x01EDE02, 0x01FE702, 0x01FD001, 0x01E2E02, 0x01EBF02, 0x0034101, 0x0227001,
-    0x01FBF01, 0x001C401, 0x01F9403, 0x01FAB03, 0x01E5102, 0x01F0101, 0x001AF01, 0x0045101,
-    0x004F001, 0x0038E01, 0x0016401, 0x01F4801, 0x004EA01, 0x01EBB01, 0x01EAF02, 0x0FB4801,
-    0x01E2201, 0x01EEA02, 0x01F7A01, 0x0FB4A01, 0x000E701, 0x01E1B01, 0x0011D01, 0x0FB3601,
-    0x0017901, 0x0012201, 0x0FB3B01, 0x01E5D02, 0x0012A01, 0x0FC5F02, 0x01EF102, 0x003D301,
-    0x0227401, 0x01FA802, 0x01FC301, 0x0FEF501, 0x0047601, 0x0022D02, 0x004DC01, 0x001FB02,
-    0x0014D01, 0x030DA01, 0x0020A01, 0x01FFC01, 0x0016201, 0x01FC901, 0x0FC5C01, 0x01FB202,
-    0x030BA01, 0x01F2702, 0x000CB01, 0x01FEA01, 0x003CA01, 0x0021601, 0x0015601, 0x003AC01,
-    0x004D301, 0x0045D01, 0x01E4801, 0x01EAD02, 0x030D701, 0x022E301, 0x01F9303, 0x001DA02,
-    0x01FC702, 0x0017501, 0x030BC01, 0x01E6602, 0x0010D01, 0x01FB402, 0x030FE01, 0x0FC6102,
-    0x01FE801, 0x01FFB01, 0x000FC01, 0x01EE401, 0x000C301, 0x01E3701, 0x000EB01, 0x001D301,
-    0x000CD01, 0x0FB1F01, 0x01E0802, 0x0FE8C01, 0x0FB4701, 0x01EE002, 0x01E6402, 0x01E9801,
-    0x0FB4101, 0x01ECE01, 0x0011201, 0x01EF301, 0x001D001, 0x0307101, 0x01E3C01, 0x01FC001,
-    0x0FCD901, 0x01E8401, 0x01E8201, 0x0FB3301, 0x01F8703, 0x01E6C01, 0x0FB4001, 0x01F6901,
-    0x01E7701, 0x01FBB01, 0x0FE7D01, 0x01E8D01, 0x0220901, 0x01E5C02, 0x0011301, 0x01E1E01,
-    0x009DC01, 0x01F1A02, 0x01FCD02, 0x0FCF202, 0x0309C01, 0x01E4D02, 0x030C701, 0x01FCE02,
-    0x01E8101, 0x000E301, 0x01E5601, 0x0FB1D01, 0x00F8102, 0x01E8701, 0x01E6201, 0x0040101,
-    0x01F2202, 0x0062601, 0x0015B01, 0x01F3901, 0x01FB901, 0x0020B01, 0x0014C01, 0x01F9203,
-    0x01E0902, 0x01E3F01, 0x01F7901, 0x01F2F02, 0x0226E01, 0x01F3B02, 0x030D101, 0x004EF01,
-    0x000B801, 0x0227901, 0x01E6001, 0x000D601, 0x0017B01, 0x01E6A01, 0x0015101, 0x01F4B02,
-    0x0010001, 0x022ED01, 0x030D601, 0x01FCB01, 0x01E3902, 0x0040701, 0x004ED01, 0x01ED202,
-    0x01EE202, 0x0304E01, 0x0FB3901, 0x0305A01, 0x01ECF01, 0x0011601, 0x01E2001, 0x0017601,
-    0x0FB3401, 0x0093101, 0x004EE01, 0x0330401, 0x0012301, 0x01FE302, 0x0020F01, 0x01FA403,
-    0x01F8F03, 0x00F7702, 0x01F5502, 0x001EF01, 0x000EA01, 0x01FAF03, 0x000FA01, 0x0022F01,
-    0x01E2901, 0x004E201, 0x004C201, 0x004EC01, 0x0039002, 0x01FB702, 0x0FC5E02, 0x0012401,
-    0x01F3A02, 0x0FB2C02, 0x01F9102, 0x0228401, 0x01EC102, 0x000F901, 0x000E801, 0x01EA101,
-    0x004E401, 0x0021A01, 0x0FB4901, 0x0017A01, 0x0010F01, 0x01FB601, 0x001FF01, 0x001E201,
-    0x004D701, 0x01F5302, 0x01EB801, 0x01FAA03, 0x0FCF402, 0x01F0901, 0x0017801, 0x0305401,
-    0x01F6202, 0x01F6E02, 0x000A801, 0x01EAB02, 0x0016B01, 0x01EA201, 0x01F9D03, 0x01F2101,
-    0x00F7601, 0x01FCC01, 0x01E3A01, 0x0013C01, 0x01E5A01, 0x001EC02, 0x0021401, 0x01EEE02,
-    0x01F8503, 0x0307901, 0x0015E01, 0x0FE8401, 0x01E7501, 0x0306501, 0x0013B01, 0x0305801,
-    0x01E8901, 0x0FC6202, 0x01E9201, 0x0011A01, 0x105E401, 0x0222601, 0x0010401, 0x01F2602,
-    0x0227501, 0x0095901, 0x01F7301, 0x0014E01, 0x01EF701, 0x0043901, 0x01E2501, 0x0FB4C01,
-    0x1109A01, 0x01F6101, 0x01E4101, 0x0010E01, 0x01FED02, 0x01EA402, 0x0021F01, 0x004D201,
-    0x01F0302, 0x003D401, 0x0307701, 0x01FB101, 0x01E1101, 0x01F1402, 0x0014401, 0x0332101,
-    0x0010C01, 0x01F4402, 0x0038502, 0x0305C01, 0x01E4301, 0x001DE02, 0x01F3702, 0x01EC502,
-    0x004DE01, 0x0306001, 0x01FE601, 0x01EC002, 0x001ED02, 0x0015401, 0x000E001, 0x01F9C03,
-    0x0021701, 0x1D15F01, 0x01E1602, 0x01ED902, 0x0FB2D02, 0x0FB3E01, 0x0020101, 0x01E4F02,
-    0x01E4001, 0x0015501, 0x004E501, 0x01FA303, 0x01EE501, 0x0020701, 0x0FC6302, 0x01E9601,
-    0x01FCF02, 0x0228001, 0x001A101, 0x0017301, 0x0022E01, 0x01F0F02, 0x01F9F03, 0x001D602,
-    0x0FB3201, 0x1D1BD02, 0x00F7902, 0x003AB01, 0x01EC202, 0x01F0B02, 0x000E401, 0x0016A01,
-    0x01F7001, 0x030D301, 0x01FA203, 0x0FF9E01, 0x01EE802, 0x01FF202, 0x01F6A02, 0x01E4E02,
-    0x01E0E01, 0x01E2701, 0x0201701, 0x030DD01, 0x00C4801, 0x01EAC02, 0x01E9B01, 0x01EF801,
-    0x021CD01, 0x00B5C01, 0x0305201, 0x0034402, 0x01F5901, 0x030B801, 0x0045301, 0x01E2B01,
-    0x0016801, 0x01F9703, 0x01FA902, 0x01EDF02, 0x030F401, 0x0FBB101, 0x01F6302, 0x01E7F01,
-    0x01EB002, 0x0017001, 0x01EE902, 0x0224401, 0x000C701, 0x01EEC02, 0x01FEC01, 0x0FE7F01,
-    0x0FEF801, 0x01EB402, 0x01EBD01, 0x01F8902, 0x01FA002, 0x01EAE02, 0x0034001, 0x01F1B02,
-    0x0010301, 0x0011C01, 0x01E1201, 0x0020E01, 0x0021001, 0x01F4001, 0x0FE8901, 0x01E1C02,
-    0x0011E01, 0x00A5901, 0x004DF01, 0x0307C01, 0x0020601, 0x003CB01, 0x0FB3A01, 0x0022B02,
-    0x002D901, 0x01F6F02, 0x00DDA01, 0x0015D01, 0x0047701, 0x030F701, 0x0FD3D01, 0x0FE7B01,
-    0x000CE01, 0x0023102, 0x0FB3001, 0x110AB01, 0x0228501, 0x0334001, 0x01E5801, 0x004F301,
-    0x001F801, 0x01F7101, 0x0017401, 0x001C601, 0x0040301, 0x01E4B01, 0x000D401, 0x01F9802,
-    0x004D601, 0x01F1101, 0x030BE01, 0x0FE7901, 0x001E102, 0x000DD01, 0x000F101, 0x01EA001,
-    0x002DA01, 0x01F3E02, 0x022AD01, 0x01F8403, 0x0045C01, 0x01EF401, 0x01E3601, 0x006D301,
-    0x01E6301, 0x004F401, 0x01E3101, 0x01E8001, 0x01FAD03, 0x01F4302, 0x0011401, 0x0016F01,
-    0x01F1202, 0x0013901, 0x01F9E03, 0x00A3301, 0x01EA502, 0x0011801, 0x01F0E02, 0x01E9101,
-    0x0203E01, 0x01E5B01, 0x000C401, 0x0021E01, 0x0017C01, 0x0226001, 0x0FEF701, 0x01F8802,
-    0x0334E01, 0x01F2502, 0x01FD302, 0x0095D01, 0x0038C01, 0x0012F01, 0x0040001, 0x01E7C01,
-    0x0017201, 0x0FB4D01, 0x01E6702, 0x00F7502, 0x01E0201, 0x0045701, 0x000D901, 0x01F0001,
-    0x01E1D02, 0x000C501, 0x0FCF302, 0x0333B01, 0x000B401, 0x01FBD01, 0x030C001, 0x004F801,
-    0x022AF01, 0x004D101, 0x001F901, 0x01E0C01, 0x0FE7001, 0x000EE01, 0x01EDD02, 0x01E7D01,
-    0x01F7801, 0x1D15E01, 0x01EB502, 0x0FB4401, 0x000E901, 0x022E201, 0x001EB01, 0x0015A01,
-    0x01F6702, 0x0219B01, 0x002DD01, 0x0017D01, 0x01E2101, 0x0022C02, 0x01E1001, 0x01E5002,
-    0x01E0601, 0x01E3001, 0x01F7601, 0x001D802, 0x0095E01, 0x0045001, 0x004F101, 0x01FDD02,
-    0x0307301, 0x004EB01, 0x01E8E01, 0x1D1BE02, 0x0020501, 0x000DC01, 0x0FE8601, 0x01F7401,
-    0x0FE4901, 0x01FA703, 0x030B201, 0x01E5501, 0x01FF301, 0x01E4901, 0x01E5E01, 0x01EB901,
-    0x01E0D01, 0x01F7C01, 0x01F5001, 0x0FBB001, 0x01ED002, 0x0FB3C01, 0x0222401, 0x003AA01,
-    0x003AF01, 0x01FB301, 0x01ECA01, 0x01E4C02, 0x0015701, 0x0040C01, 0x01EDA02, 0x01E3401,
-    0x01E1301, 0x01F0502, 0x0020C01, 0x01FEE02, 0x01F5B02, 0x004F901, 0x01FD601, 0x0FB2E01,
-    0x01E4501, 0x000ED01, 0x0045E01, 0x01FE901, 0x0020001, 0x0012101, 0x01E8F01, 0x0013601,
-    0x0020301, 0x1D16302, 0x001E801, 0x001F401, 0x01E8A01, 0x01FC102, 0x01EDB02, 0x01F2D02,
-    0x0016301, 0x01F2801, 0x000E201, 0x000C201, 0x01EF901, 0x01FBC01, 0x01FB801, 0x021CF01,
-    0x009DF01, 0x01E3D01, 0x01EB602, 0x01F8603, 0x0022A02, 0x0010501, 0x01FC801, 0x0040E01,
-    0x0037A01, 0x01F8B03, 0x01F4A02, 0x01F0D02, 0x01ED102, 0x01E8C01, 0x01EB102, 0x01E3B01,
-    0x0FC5B01, 0x021CE01, 0x01E3E01, 0x004DD01, 0x01E4401, 0x01F6502, 0x0FEF601, 0x004F201,
-    0x030F801, 0x002D801, 0x01EC801, 0x01EE701, 0x000FD01, 0x01ED702, 0x01EBC01, 0x0011501,
-    0x01F5F02, 0x0FE7801, 0x01E7802, 0x1D16002, 0x0038901, 0x1D1BB01, 0x0010701, 0x0306901,
-    0x0FB4301, 0x0016C01, 0x01EF501, 0x01FB001, 0x01F3801, 0x0228801, 0x01FDE02, 0x0226F01,
-    0x0FE8501, 0x0FE7201, 0x003CD01, 0x0021801, 0x0013501, 0x01F8203, 0x0020901, 0x01FD101,
-    0x000F201, 0x0021101, 0x0014601, 0x1D16202, 0x01E5F01, 0x004DB01, 0x0015F01, 0x02ADC01,
-    0x0095B01, 0x01F6001, 0x01FDB01, 0x0FB4E01, 0x0228901, 0x01E2301, 0x0305601, 0x022AC01,
-    0x01E7301, 0x01E7A02, 0x01E7401, 0x01FBA01, 0x001FE01, 0x01EB302, 0x01F2402, 0x0FD3C01,
-    0x01E7201, 0x0038401, 0x0012E01, 0x0013701, 0x000EF01, 0x01E0101, 0x021AE01, 0x0333201,
-    0x000DA01, 0x001DB02, 0x001F001, 0x01E5202, 0x0307D01, 0x000F301, 0x001EA01, 0x0012D01,
-    0x01ED802, 0x01F2001, 0x00B5D01, 0x0021901, 0x01E1502, 0x0FE4A01, 0x01FD801, 0x01F1C02,
-    0x0020201, 0x000C801, 0x01EEB02, 0x01E2401, 0x004F501, 0x01FAC03, 0x030DC01, 0x022AE01,
-    0x030F901, 0x01E2A01, 0x01EF002, 0x01E0701, 0x01F3D02, 0x01FE001, 0x01F7201, 0x01ED402,
-    0x001FC01, 0x0012001, 0x01F7701, 0x0304C01, 0x01E4201, 0x0062201, 0x004E301, 0x01FEB01,
-    0x01ECD01, 0x01FC402, 0x01E8501, 0x01F5202, 0x01F6D02, 0x01EA301, 0x030C201, 0x0095A01,
-    0x01F3202, 0x01F8102, 0x01E2801, 0x006C201, 0x01E9901, 0x0017101, 0x01F2A02, 0x01ED602,
-    0x001E601, 0x01F3001, 0x01F3F02, 0x000C001, 0x000DB01, 0x000F601, 0x1D16402, 0x01EBA01,
-    0x0015901, 0x0331E01, 0x000C901, 0x030C901, 0x0FC5D01, 0x01F8A03, 0x0020401, 0x01E1901,
-    0x01F4D02, 0x01F2C02, 0x01FF901, 0x0013401, 0x01EB202, 0x0015C01, 0x01E6F01, 0x0FE8301,
-    0x001D401, 0x001F501, 0x01F8D03, 0x0093401, 0x0041901, 0x0038801, 0x009DD01, 0x01EBE02,
-    0x01EC602, 0x01F5702, 0x01E6101, 0x0010A01, 0x002DB01, 0x001C501, 0x001E002, 0x0014701,
-    0x0306701, 0x0012C01, 0x022E101, 0x01F4202, 0x004DA01, 0x0023301, 0x01E2601, 0x01F1302,
-    0x01F8C03, 0x022EC01, 0x0062501, 0x01F5D02, 0x01E8B01, 0x1F21301, 0x0010101, 0x01ED502,
-    0x01FE202, 0x003AD01, 0x000D201, 0x01FF601, 0x001E901, 0x000C101, 0x01F1001, 0x01E9701,
-    0x01E0301, 0x030B601, 0x01E1A01, 0x001CE01, 0x001B001, 0x0011F01, 0x0022701, 0x01E3501,
-    0x01F0602, 0x001E701, 0x01ED302, 0x01FFD01, 0x01E2D01, 0x0092901, 0x01E8301, 0x0062301,
-    0x01E6E01, 0x0306201, 0x0021501, 0x0228101, 0x000CA01, 0x01E5701, 0x01FDA01, 0x01F4502,
-    0x0FE8101, 0x01E5302, 0x0022601, 0x000E501, 0x0FE8A01, 0x01E9001, 0x022E001, 0x01F9603,
-    0x01EA602, 0x001D902, 0x01F2901, 0x01F5402, 0x0FB2B01, 0x01FD702, 0x001D502, 0x0FF9F01,
-    0x0FE7101, 0x001E301, 0x000CF01, 0x01FCA01, 0x01F8E03, 0x01E4701, 0x000AF01, 0x0FE7E01,
-    0x0FE7401, 0x0FB2A01, 0x01F7501, 0x0334B01, 0x001D201, 0x022EA01, 0x001CF01, 0x01E6502,
-    0x002DC01, 0x01F3C02, 0x0307A01, 0x001DF02, 0x001EE01, 0x0305001, 0x01E7902, 0x00DDD01,
-    0x01EA802, 0x0021201, 0x01E2F02, 0x0FE4C01, 0x0040D01, 0x01F4101, 0x0023201, 0x01E8801,
-    0x01F2302, 0x01EED02, 0x01F0C02, 0x0FB4601, 0x01F6801, 0x0062401, 0x01E2C01, 0x01ECB01,
-    0x0FE8701, 0x01E5901, 0x01E0A01, 0x01E1F01, 0x00A5A01, 0x0017701, 0x01E5401, 0x0FB2F01,
-    0x01FAE03, 0x00A3601, 0x01ECC01, 0x0FB3501, 0x000D301, 0x01EF601, 0x01F8303, 0x0FEFA01,
-    0x0095F01, 0x01FFA01, 0x01E3301, 0x01E1801, 0x0FB4B01, 0x01E7E01, 0x00A5E01, 0x0330701,
-    0x01E6D01, 0x030FA01, 0x000EC01, 0x01F0202, 0x0038601, 0x01F5101, 0x01F1901, 0x01F1502,
-    0x0016001, 0x01E4601, 0x0038A01, 0x0FC9001, 0x0016901, 0x01F1801, 0x0220C01, 0x01E0B01,
-    0x030C501, 0x0020D01, 0x01F9B03, 0x0021301, 0x0010601, 0x0FE7A01, 0x00F7801, 0x0013A01,
-    0x01E6B01, 0x01FE501, 0x0012801, 0x001FD01, 0x01E6902, 0x0FE8201, 0x01F4901, 0x01E3201,
-    0x01E0001, 0x1109C01, 0x01F7B01, 0x0FE8801, 0x0FE4B01, 0x0010B01, 0x000D501, 0x01F6402,
-    0x001CD01, 0x01E1702, 0x01FA503, 0x01FD901, 0x01EC402, 0x004E601, 0x0014801, 0x001D101,
-    0x01F9902, 0x01F6B02, 0x01F8002, 0x0FBA501, 0x01EC702, 0x01F6602, 0x0015001, 0x0212B01,
-    0x0013E01, 0x01EDC02, 0x01EA702, 0x0023002, 0x004C101, 0x0016D01, 0x01F0702, 0x01F2B02,
-    0x0012501, 0x01F4C02, 0x030D001, 0x0305E01, 0x0010201, 0x006C001, 0x0309401, 0x0012901,
-    0x0016101, 0x0224701, 0x0011901, 0x0FFE301, 0x01E0501, 0x105C901, 0x1D1BC01, 0x0307001,
-    0x0017E01, 0x01FA603, 0x01FA102, 0x01E9401, 0x0309B01, 0x0022801, 0x01E0F01, 0x0016501,
-    0x01EC302, 0x0020801, 0x000CC01, 0x01F9002, 0x003CC01, 0x01FC601, 0x01EE302, 0x01E4A01,
-    0x003CE01, 0x0095C01, 0x01FF702, 0x001D702, 0x0227101, 0x01EE102, 0x01E7101, 0x000FB01,
-    0x0095801, 0x01EAA02, 0x000F501, 0x1D1BF02, 0x0011B01, 0x01F7D01, 0x022EB01, 0x0013D01,
-    0x01F0801, 0x0014F01, 0x01F3602, 0x0FB3101, 0x01FE401, 0x01F9503, 0x0014301, 0x0015801,
-    0x01EE601, 0x0FE7C01, 0x01FDF02, 0x01E0401, 0x01E7001, 0x0331001, 0x000F401, 0x0FE7701,
-    0x01E1402, 0x0FE7601, 0x01E3802, 0x030B401, 0x01F3402, 0x0226D01, 0x000FF01, 0x01E8601,
-    0x0014501, 0x0013001, 0x030D901, 0x001DC02, 0x01EF201, 0x0FBA401, 0x01FF402, 0x01E9501,
-    0x030AE01, 0x0010901, 0x0219A01, 0x000D101,
-];
diff --git a/third_party/rust/unicode-normalization/src/test.rs b/third_party/rust/unicode-normalization/src/test.rs
@@ -1,130 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::char::is_combining_mark;
-use super::UnicodeNormalization;
-use core::char;
-
-#[cfg(not(feature = "std"))]
-use alloc::string::{String, ToString};
-
-#[test]
-fn test_nfd() {
-    macro_rules! t {
-        ($input: expr, $expected: expr) => {
-            assert_eq!($input.nfd().to_string(), $expected);
-            // A dummy iterator that is not std::str::Chars directly;
-            // note that `id_func` is used to ensure `Clone` implementation
-            assert_eq!(
-                $input.chars().map(|c| c).nfd().collect::<String>(),
-                $expected
-            );
-        };
-    }
-    t!("abc", "abc");
-    t!("\u{1e0b}\u{1c4}", "d\u{307}\u{1c4}");
-    t!("\u{2026}", "\u{2026}");
-    t!("\u{2126}", "\u{3a9}");
-    t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
-    t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
-    t!("a\u{301}", "a\u{301}");
-    t!("\u{301}a", "\u{301}a");
-    t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
-    t!("\u{ac1c}", "\u{1100}\u{1162}");
-}
-
-#[test]
-fn test_nfkd() {
-    macro_rules! t {
-        ($input: expr, $expected: expr) => {
-            assert_eq!($input.nfkd().to_string(), $expected);
-        };
-    }
-    t!("abc", "abc");
-    t!("\u{1e0b}\u{1c4}", "d\u{307}DZ\u{30c}");
-    t!("\u{2026}", "...");
-    t!("\u{2126}", "\u{3a9}");
-    t!("\u{1e0b}\u{323}", "d\u{323}\u{307}");
-    t!("\u{1e0d}\u{307}", "d\u{323}\u{307}");
-    t!("a\u{301}", "a\u{301}");
-    t!("\u{301}a", "\u{301}a");
-    t!("\u{d4db}", "\u{1111}\u{1171}\u{11b6}");
-    t!("\u{ac1c}", "\u{1100}\u{1162}");
-}
-
-#[test]
-fn test_nfc() {
-    macro_rules! t {
-        ($input: expr, $expected: expr) => {
-            assert_eq!($input.nfc().to_string(), $expected);
-        };
-    }
-    t!("abc", "abc");
-    t!("\u{1e0b}\u{1c4}", "\u{1e0b}\u{1c4}");
-    t!("\u{2026}", "\u{2026}");
-    t!("\u{2126}", "\u{3a9}");
-    t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
-    t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
-    t!("a\u{301}", "\u{e1}");
-    t!("\u{301}a", "\u{301}a");
-    t!("\u{d4db}", "\u{d4db}");
-    t!("\u{ac1c}", "\u{ac1c}");
-    t!(
-        "a\u{300}\u{305}\u{315}\u{5ae}b",
-        "\u{e0}\u{5ae}\u{305}\u{315}b"
-    );
-}
-
-#[test]
-fn test_nfkc() {
-    macro_rules! t {
-        ($input: expr, $expected: expr) => {
-            assert_eq!($input.nfkc().to_string(), $expected);
-        };
-    }
-    t!("abc", "abc");
-    t!("\u{1e0b}\u{1c4}", "\u{1e0b}D\u{17d}");
-    t!("\u{2026}", "...");
-    t!("\u{2126}", "\u{3a9}");
-    t!("\u{1e0b}\u{323}", "\u{1e0d}\u{307}");
-    t!("\u{1e0d}\u{307}", "\u{1e0d}\u{307}");
-    t!("a\u{301}", "\u{e1}");
-    t!("\u{301}a", "\u{301}a");
-    t!("\u{d4db}", "\u{d4db}");
-    t!("\u{ac1c}", "\u{ac1c}");
-    t!(
-        "a\u{300}\u{305}\u{315}\u{5ae}b",
-        "\u{e0}\u{5ae}\u{305}\u{315}b"
-    );
-}
-
-#[test]
-fn test_normalize_char() {
-    assert_eq!('\u{2126}'.nfd().to_string(), "\u{3a9}")
-}
-
-#[test]
-fn test_is_combining_mark_ascii() {
-    for cp in 0..0x7f {
-        assert!(!is_combining_mark(char::from_u32(cp).unwrap()));
-    }
-}
-
-#[test]
-fn test_is_combining_mark_misc() {
-    // https://github.com/unicode-rs/unicode-normalization/issues/16
-    // U+11C3A BHAIKSUKI VOWEL SIGN O
-    // Category: Mark, Nonspacing [Mn]
-    assert!(is_combining_mark('\u{11C3A}'));
-
-    // U+11C3F BHAIKSUKI SIGN VIRAMA
-    // Category: Mark, Nonspacing [Mn]
-    assert!(is_combining_mark('\u{11C3F}'));
-}
diff --git a/third_party/rust/viaduct/.cargo-checksum.json b/third_party/rust/viaduct/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"0b5140ab92d21de6dac878ac7879062b447782634c5837686276990de77661ff","README.md":"d73ab3e981a55c60a3c0995daa46fee6e513e8d78fb3c34691dd47320547695e","src/backend.rs":"501657c02aff05a987eb9d1a94aef8725a4db0af8a4d7c4959a49b3dc048fa68","src/backend/ffi.rs":"1c07fbfd807ee63ce32d5ac1000b8e0eef0a660ac4aa48c6ff15abf59fdadb75","src/client.rs":"0c35db14ba2a1952a1543bc3e8307bfb94de4b73964f58aecbac599a562b2246","src/error.rs":"2bf09dee6a0fbce7f0a7ffb4d5a01c59d458634336e8767399ed42ce7e9b1287","src/fetch_msg_types.proto":"de8a46a4947a140783a4d714364f18ccf02c4759d6ab5ace9da0b1c058efa6c3","src/headers.rs":"63bfa3ba4953f1900a56e3cc6e15b0eb8bd1268cdb0020a1b86391f1043dab82","src/headers/name.rs":"d7304e006278a5466b5fe09e194a9ca921b565d76e24be491ec6178f527d2d61","src/lib.rs":"9eb7c5a81feca0cf7fa22af3d1f32e8043bf7259765c4018e8cd53ee65d91933","src/mozilla.appservices.httpconfig.protobuf.rs":"9ede762489a0c07bc08a5b852b33013a410cb41b44b92a44555f85bb2db91412","src/new_backend.rs":"c2a7211498c89b3445f0048a79a1d3a4f5e10e53a304fe126cff04a165f90c4e","src/ohttp.rs":"d2edbb15f15d3ade8fad1eb13a767fcfe65e6b0b76b3bfb599af379608be4575","src/ohttp_client.rs":"cb91882a05ddcc1fe759dcab0d4cff7570571600922bef9cce3207b6a79fe249","src/settings.rs":"d2788035fed3bbbb43ed4ddbb832fbd98019cce1c34e32ffa21c74a8c127b540","uniffi.toml":"d73e88bf94a6b2c4a94bd0bada509542dbbadb3be1bf4ad32f52e465af6503d7"},"package":null}
-\ No newline at end of file
+{"files":{"Cargo.toml":"a9bc386ac1ca3672255d64571b3cf03aad46bf5ad503586dc94e16228db93fb4","README.md":"d73ab3e981a55c60a3c0995daa46fee6e513e8d78fb3c34691dd47320547695e","src/backend.rs":"501657c02aff05a987eb9d1a94aef8725a4db0af8a4d7c4959a49b3dc048fa68","src/backend/ffi.rs":"1c07fbfd807ee63ce32d5ac1000b8e0eef0a660ac4aa48c6ff15abf59fdadb75","src/client.rs":"0c35db14ba2a1952a1543bc3e8307bfb94de4b73964f58aecbac599a562b2246","src/error.rs":"2bf09dee6a0fbce7f0a7ffb4d5a01c59d458634336e8767399ed42ce7e9b1287","src/fetch_msg_types.proto":"de8a46a4947a140783a4d714364f18ccf02c4759d6ab5ace9da0b1c058efa6c3","src/headers.rs":"63bfa3ba4953f1900a56e3cc6e15b0eb8bd1268cdb0020a1b86391f1043dab82","src/headers/name.rs":"d7304e006278a5466b5fe09e194a9ca921b565d76e24be491ec6178f527d2d61","src/lib.rs":"9eb7c5a81feca0cf7fa22af3d1f32e8043bf7259765c4018e8cd53ee65d91933","src/mozilla.appservices.httpconfig.protobuf.rs":"9ede762489a0c07bc08a5b852b33013a410cb41b44b92a44555f85bb2db91412","src/new_backend.rs":"c2a7211498c89b3445f0048a79a1d3a4f5e10e53a304fe126cff04a165f90c4e","src/ohttp.rs":"d2edbb15f15d3ade8fad1eb13a767fcfe65e6b0b76b3bfb599af379608be4575","src/ohttp_client.rs":"cb91882a05ddcc1fe759dcab0d4cff7570571600922bef9cce3207b6a79fe249","src/settings.rs":"d2788035fed3bbbb43ed4ddbb832fbd98019cce1c34e32ffa21c74a8c127b540","uniffi.toml":"d73e88bf94a6b2c4a94bd0bada509542dbbadb3be1bf4ad32f52e465af6503d7"},"package":null}
+\ No newline at end of file
diff --git a/third_party/rust/viaduct/Cargo.toml b/third_party/rust/viaduct/Cargo.toml
@@ -48,7 +48,7 @@ async-trait = "0.1"
 ffi-support = "0.4"
 once_cell = "1.5"
 pollster = "0.3.0"
-prost = "0.12"
+prost = "0.13"
 serde = "1"
 serde_json = "1"
 thiserror = "2"
diff --git a/toolkit/components/gecko-trace/Cargo.toml b/toolkit/components/gecko-trace/Cargo.toml
@@ -13,7 +13,7 @@ log = "0.4.0"
 mozbuild = { path = "../../../build/rust/mozbuild/" }
 nserror = { path = "../../../xpcom/rust/nserror/" }
 once_cell = "*"
-prost = { version = "0.12", default-features = false, features = [
+prost = { version = "0.13.5", default-features = false, features = [
   "prost-derive",
 ] }
 xpcom = { path = "../../../xpcom/rust/xpcom/" }
diff --git a/toolkit/content/license.html b/toolkit/content/license.html
@@ -5724,6 +5724,8 @@ product.
               <li><code>intl/icu_segmenter_data</code></li>
               <li><code>third_party/rust/icu_calendar</code></li>
               <li><code>third_party/rust/icu_calendar_data</code></li>
+              <li><code>third_party/rust/icu_casemap</code></li>
+              <li><code>third_party/rust/icu_casemap_data</code></li>
               <li><code>third_party/rust/icu_collections</code></li>
               <li><code>third_party/rust/icu_locale</code></li>
               <li><code>third_party/rust/icu_locale_core</code></li>

	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE

M	.cargo/config.toml.in	\|	4	++--
M	Cargo.lock	\|	129	+++++++++++++++++++++++++++++++++++++------------------------------------------
M	Cargo.toml	\|	33	+++++++++++++++------------------
D	build/rust/itertools/Cargo.toml	\|	17	-----------------
D	build/rust/itertools/lib.rs	\|	5	-----
M	python/mozbuild/mozbuild/vendor/vendor_rust.py	\|	4	+---
M	supply-chain/imports.lock	\|	35	++++++++++++++++++++++++++++-------
M	third_party/rust/error-support/.cargo-checksum.json	\|	4	++--
M	third_party/rust/error-support/src/error_tracing.rs	\|	27	++++++++++++++++++++++++++-
A	third_party/rust/icu_casemap/.cargo-checksum.json	\|	2	++
A	third_party/rust/icu_casemap/Cargo.lock	\|	903	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/Cargo.toml	\|	161	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/LICENSE	\|	46	++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/README.md	\|	34	++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/benches/casemap.rs	\|	121	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/benches/data/Iliad.txt	\|	50	++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/casemapper.rs	\|	806	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/closer.rs	\|	287	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/greek_to_me/data.rs	\|	24	++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/greek_to_me/mod.rs	\|	321	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/internals.rs	\|	865	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/lib.rs	\|	70	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/provider/data.rs	\|	527	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/provider/exception_helpers.rs	\|	279	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/provider/exceptions.rs	\|	566	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/provider/exceptions_builder.rs	\|	290	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/provider/mod.rs	\|	202	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/provider/unfold.rs	\|	105	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/set.rs	\|	36	++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/src/titlecase.rs	\|	486	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/tests/conversions.rs	\|	409	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap/tests/gen_greek_to_me.rs	\|	202	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap_data/.cargo-checksum.json	\|	2	++
A	third_party/rust/icu_casemap_data/Cargo.lock	\|	7	+++++++
A	third_party/rust/icu_casemap_data/Cargo.toml	\|	60	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap_data/LICENSE	\|	46	++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap_data/README.md	\|	14	++++++++++++++
A	third_party/rust/icu_casemap_data/build.rs	\|	11	+++++++++++
A	third_party/rust/icu_casemap_data/data/case_map_unfold_v1.rs.data	\|	80	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap_data/data/case_map_v1.rs.data	\|	75	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap_data/data/mod.rs	\|	36	++++++++++++++++++++++++++++++++++++
A	third_party/rust/icu_casemap_data/src/lib.rs	\|	17	+++++++++++++++++
M	third_party/rust/nss/.cargo-checksum.json	\|	4	++--
M	third_party/rust/nss/src/pk11/sym_key.rs	\|	19	+++++++------------
M	third_party/rust/nss_sys/.cargo-checksum.json	\|	4	++--
M	third_party/rust/nss_sys/src/bindings/pk11pub.rs	\|	5	-----
M	third_party/rust/prost-derive/.cargo-checksum.json	\|	4	++--
A	third_party/rust/prost-derive/Cargo.lock	\|	70	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M	third_party/rust/prost-derive/Cargo.toml	\|	24	+++++++++++++++---------
M	third_party/rust/prost-derive/src/field/group.rs	\|	9	+++++----
M	third_party/rust/prost-derive/src/field/message.rs	\|	12	+++++-------
M	third_party/rust/prost-derive/src/field/mod.rs	\|	8	++------
M	third_party/rust/prost-derive/src/field/oneof.rs	\|	12	+++++-------
M	third_party/rust/prost-derive/src/field/scalar.rs	\|	12	++++++------
M	third_party/rust/prost-derive/src/lib.rs	\|	230	++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------
M	third_party/rust/prost/.cargo-checksum.json	\|	4	++--
A	third_party/rust/prost/Cargo.lock	\|	787	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M	third_party/rust/prost/Cargo.toml	\|	49	+++++++++++++++++++++++++------------------------
D	third_party/rust/prost/FUZZING.md	\|	27	---------------------------
D	third_party/rust/prost/KANI.md	\|	69	---------------------------------------------------------------------
M	third_party/rust/prost/README.md	\|	29	++++++++++++++++++-----------
M	third_party/rust/prost/benches/varint.rs	\|	2	+-
D	third_party/rust/prost/clippy.toml	\|	1	-
D	third_party/rust/prost/flake.lock	\|	43	-------------------------------------------
D	third_party/rust/prost/flake.nix	\|	20	--------------------
D	third_party/rust/prost/prepare-release.sh	\|	47	-----------------------------------------------
D	third_party/rust/prost/publish-release.sh	\|	33	---------------------------------
M	third_party/rust/prost/src/encoding.rs	\|	494	+++++++++++--------------------------------------------------------------------
A	third_party/rust/prost/src/encoding/length_delimiter.rs	\|	53	+++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/prost/src/encoding/varint.rs	\|	274	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	third_party/rust/prost/src/encoding/wire_type.rs	\|	49	+++++++++++++++++++++++++++++++++++++++++++++++++
M	third_party/rust/prost/src/error.rs	\|	49	+++++++++++++++++++++++++++++++++++++++++++++++++
M	third_party/rust/prost/src/lib.rs	\|	67	+++++++------------------------------------------------------------
M	third_party/rust/prost/src/message.rs	\|	51	+++++++++++++++++++--------------------------------
M	third_party/rust/prost/src/name.rs	\|	18	++++++++++++------
M	third_party/rust/prost/src/types.rs	\|	374	+++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------
M	third_party/rust/remote_settings/.cargo-checksum.json	\|	4	++--
M	third_party/rust/remote_settings/dumps/main/search-config-v2.json	\|	62	++++++++++++++++++++++++++++++++++++++++++--------------------
M	third_party/rust/remote_settings/dumps/main/search-telemetry-v2.json	\|	70	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
M	third_party/rust/remote_settings/dumps/main/summarizer-models-config.json	\|	23	++++++++++++-----------
M	third_party/rust/suggest/.cargo-checksum.json	\|	4	++--
M	third_party/rust/suggest/Cargo.toml	\|	9	+++++++--
M	third_party/rust/suggest/src/util.rs	\|	31	+++++++++++++++++++++++++------
D	third_party/rust/tinyvec/.cargo-checksum.json	\|	2	--
D	third_party/rust/tinyvec/CHANGELOG.md	\|	104	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/Cargo.lock	\|	647	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/Cargo.toml	\|	158	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/LICENSE-APACHE.md	\|	202	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/LICENSE-MIT.md	\|	5	-----
D	third_party/rust/tinyvec/LICENSE-ZLIB.md	\|	11	-----------
D	third_party/rust/tinyvec/README.md	\|	34	----------------------------------
D	third_party/rust/tinyvec/benches/macros.rs	\|	52	----------------------------------------------------
D	third_party/rust/tinyvec/benches/smallvec.rs	\|	503	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/debug_metadata/README.md	\|	111	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/debug_metadata/tinyvec.natvis	\|	25	-------------------------
D	third_party/rust/tinyvec/rustfmt.toml	\|	14	--------------
D	third_party/rust/tinyvec/src/array.rs	\|	54	------------------------------------------------------
D	third_party/rust/tinyvec/src/array/const_generic_impl.rs	\|	23	-----------------------
D	third_party/rust/tinyvec/src/array/generated_impl.rs	\|	9616	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/src/array/generic_array_impl.rs	\|	26	--------------------------
D	third_party/rust/tinyvec/src/arrayvec.rs	\|	2079	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/src/arrayvec_drain.rs	\|	99	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/src/lib.rs	\|	112	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/src/slicevec.rs	\|	1083	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/src/tinyvec.rs	\|	1910	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/tests/arrayvec.rs	\|	500	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/tests/debugger_visualizer.rs	\|	91	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec/tests/tinyvec.rs	\|	501	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec_macros/.cargo-checksum.json	\|	2	--
D	third_party/rust/tinyvec_macros/Cargo.toml	\|	19	-------------------
D	third_party/rust/tinyvec_macros/LICENSE-APACHE.md	\|	202	-------------------------------------------------------------------------------
D	third_party/rust/tinyvec_macros/LICENSE-MIT.md	\|	21	---------------------
D	third_party/rust/tinyvec_macros/LICENSE-ZLIB.md	\|	20	--------------------
D	third_party/rust/tinyvec_macros/src/lib.rs	\|	25	-------------------------
D	third_party/rust/unicode-normalization/.cargo-checksum.json	\|	2	--
D	third_party/rust/unicode-normalization/COPYRIGHT	\|	7	-------
D	third_party/rust/unicode-normalization/Cargo.toml	\|	66	------------------------------------------------------------------
D	third_party/rust/unicode-normalization/LICENSE-APACHE	\|	201	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/LICENSE-MIT	\|	25	-------------------------
D	third_party/rust/unicode-normalization/README.md	\|	39	---------------------------------------
D	third_party/rust/unicode-normalization/benches/bench.rs	\|	127	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/scripts/unicode.py	\|	617	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/__test_api.rs	\|	18	------------------
D	third_party/rust/unicode-normalization/src/decompose.rs	\|	173	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/lib.rs	\|	227	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/lookups.rs	\|	138	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/normalize.rs	\|	224	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/perfect_hash.rs	\|	50	--------------------------------------------------
D	third_party/rust/unicode-normalization/src/quick_check.rs	\|	190	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/recompose.rs	\|	169	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/replace.rs	\|	66	------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/stream_safe.rs	\|	174	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/tables.rs	\|	22803	-------------------------------------------------------------------------------
D	third_party/rust/unicode-normalization/src/test.rs	\|	130	-------------------------------------------------------------------------------
M	third_party/rust/viaduct/.cargo-checksum.json	\|	4	++--
M	third_party/rust/viaduct/Cargo.toml	\|	2	+-
M	toolkit/components/gecko-trace/Cargo.toml	\|	2	+-
M	toolkit/content/license.html	\|	2	++