[unicode] add unicode libraries for rustyline support

Change-Id: I182e5f883e1df1956c915672e08595b649edb94e
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index d5ec3fb..b247193 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -193,6 +193,11 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
+name = "encode_unicode"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
 name = "failure"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -237,6 +242,7 @@
  "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.31.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "encode_unicode 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "futures 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "getopts 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -260,6 +266,8 @@
  "tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
  "timebomb 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-segmentation 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "url 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "xi-core-lib 0.2.0",
  "xi-rpc 0.2.0",
@@ -944,6 +952,11 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
+name = "unicode-segmentation"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
 name = "unicode-width"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1108,6 +1121,7 @@
 "checksum digest 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "00a49051fef47a72c9623101b19bd71924a45cca838826caae3eaa4d00772603"
 "checksum dtoa 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "09c3753c3db574d215cba4ea76018483895d7bff25a31b49ba45db21c48e50ab"
 "checksum either 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3be565ca5c557d7f59e7cfcf1844f9e3033650c929c6566f511e8005f205c1d0"
+"checksum encode_unicode 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "28d65f1f5841ef7c6792861294b72beda34c664deb8be27970f36c306b7da1ce"
 "checksum failure 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "934799b6c1de475a012a02dab0ace1ace43789ee4b99bcfbf1a2e3e8ced5de82"
 "checksum failure_derive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c7cdda555bb90c9bb67a3b670a0f42de8e73f5981524123ad8578aafec8ddb8b"
 "checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
@@ -1194,6 +1208,7 @@
 "checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"
 "checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
 "checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"
+"checksum unicode-segmentation 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "aa6024fc12ddfd1c6dbc14a80fa2324d4568849869b779f6bd37e5e4c03344d1"
 "checksum unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bf3a113775714a22dcb774d8ea3655c53a32debae63a063acc00a91cc586245f"
 "checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
 "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index b9658ff..24f46fc 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -16,6 +16,7 @@
 cc = "1"
 clap = "2.29"
 crossbeam = "0.3.2"
+encode_unicode = "0.1.3"
 failure = "0.1.1"
 futures = "0.2.1"
 getopts = "0.2"
@@ -39,6 +40,8 @@
 tempdir = "0.3"
 time = "0.1"
 timebomb = "0.1.2"
+unicode-segmentation = "1.0"
+unicode-width = "0.1.3"
 url = "1.7.0"
 xi-core-lib = { version = "0.2.0", default-features = false } # disable "notify" crate
 xi-rpc = "0.2.0"
diff --git a/rustc_deps/vendor/encode_unicode/.cargo-checksum.json b/rustc_deps/vendor/encode_unicode/.cargo-checksum.json
new file mode 100644
index 0000000..a7388c5
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7a332159e56fb478b9a35e403ca494dd230e4c239b449f293b73c5c582ce6587","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"629c4212f7b7d7669a2356639903720f661d9ee890fee70f18663862e045fa42","README.md":"ea27d350eec0d77fdc6ad52ec9de3f8c3f48bd00c705fdb8bb3bf59a4c7ce79e","src/errors.rs":"1e05de4001b98131d0a0b5e441a660445e338b12b6af3aa991397987df427dc4","src/lib.rs":"193453714154c122f33e1eb65fdee67cef0e10dff9f316fb5245fc48a233095e","src/traits.rs":"3ce2a4340454483e2b3ea52a4abe2dbe4a5c1d4a31ebdf286b62de5e6bbcd3a6","src/utf16_char.rs":"78fe2d79e160ebba6621f2206c0c972ed07e0ae72e93bad59e7164df62a61d5e","src/utf16_iterator.rs":"9e727543b40a9bf85f4ccc293de449b02dc7a992b2978da08cee7a98d9045d8e","src/utf8_char.rs":"c4bc3b27ef1d9de65a29e3f5329bf61adfcf2ce78f07c1cb869a389ffa450390","src/utf8_iterator.rs":"ba2ffe56040db7f06044ddf7325144756f54ceb799f6f2921a8d07af2fcdac3e","tests/fail_tests.rs":"e12930ca7097eb2ece5037e9b4e9c7ff25b862cc57453a92ffd008462df6b273","tests/iterator_tests.rs":"ede7c8cf2ae0f331653c218f061b920bcd7429b5ab9169c3be92ebfa6699a1b0","tests/pass_tests.rs":"a9e9ad99750fb88fead790b71e8a0dd3466b75dd14dc3949169320f9bc467328"},"package":"28d65f1f5841ef7c6792861294b72beda34c664deb8be27970f36c306b7da1ce"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/encode_unicode/Cargo.toml b/rustc_deps/vendor/encode_unicode/Cargo.toml
new file mode 100644
index 0000000..7d0c7ce
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "encode_unicode"
+keywords = ["unicode"]
+description = """
+Alternative and extension to the unstable `char.encode_utf8()` and char.encode_utf16()` methods.
+"""
+readme = "README.md"
+version = "0.1.3"
+license = "MIT/Apache-2.0"
+repository = "https://github.com/tormol/encode_unicode"
+documentation = "http://tormol.github.io/rustdoc/encode_unicode"
+authors = ["Torbjørn Birch Moltu <t.b.moltu@lyse.net>"]
+
+[dependencies]
+ascii = {optional=true, version="0.6"}
+clippy = {optional=true, version="0.*"}# wildest wildcard crates.io will allow.
diff --git a/rustc_deps/vendor/encode_unicode/LICENSE-APACHE b/rustc_deps/vendor/encode_unicode/LICENSE-APACHE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/LICENSE-APACHE
@@ -0,0 +1,202 @@
+
+                                 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/rustc_deps/vendor/encode_unicode/LICENSE-MIT b/rustc_deps/vendor/encode_unicode/LICENSE-MIT
new file mode 100644
index 0000000..be5235a
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/LICENSE-MIT
@@ -0,0 +1,19 @@
++Copyright (c) 2016 encode-unicode 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/rustc_deps/vendor/encode_unicode/README.md b/rustc_deps/vendor/encode_unicode/README.md
new file mode 100644
index 0000000..8ac8f52
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/README.md
@@ -0,0 +1,38 @@
+# encode_unicode
+Alternative and extension to to the unstable `char.encode_utf8()` and `char.encode_utf16()`.
+
+The goal was to fill in those methods for stable via a trait,
+but that didn't work since the methods already exist; they're just un-callable.
+
+## Contains:
+* **Utf8Char**: A `char` stored as UTF-8. Can be borrowed as a `str`.
+* **Utf8Iterator**: Iterate over or read the bytes of an UTF-8 codepoint.
+* **Utf16Char**: A `char` stored as UTF-16. Can be borrowed as a `u16` slice.
+* **Utf8Iterator**: Iterate over the units of an UTF-16 codepoint.
+* **Conversion methods on `char`**:
+  * to UTF-8 as `[u8; 4]` or into `&mut[u8]`. and vice versa.
+  * to UTF-16 as `(u16, Option<u16>)` or into `&mut[u16]`. and vice versa.
+* **Precise errors when decoding a char from UTF-8, UTF-16 or `u32` fails.**
+
+## Feature flags:
+(both require nightly)
+* **ascii**: Implement `AsciiExt` and integrate with [ascii](https://tomprogrammer.github.io/rust-ascii/ascii/index.html)::`Ascii`.
+* **clippy**: Get extra warnings, see lib.rs for why I haven't fixed or `allow()`ed them.
+
+The unit tests only work on nightly since they use encode_utf{8,16}() as a reference.
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you, as defined in the Apache-2.0
+license, shall be dual licensed as above, without any additional terms or
+conditions.
diff --git a/rustc_deps/vendor/encode_unicode/src/errors.rs b/rustc_deps/vendor/encode_unicode/src/errors.rs
new file mode 100644
index 0000000..fa129d2
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/errors.rs
@@ -0,0 +1,241 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+
+//! Boilerplatey error enums
+
+
+extern crate std;
+use std::fmt::{self,Display,Formatter};
+use std::error::Error;
+
+
+
+/// Reason why Utf8Char::from_str() failed.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum FromStrError {
+    /// Utf8Char cannot store more than a single codepoint.
+    SeveralCodePoints,
+    /// Utf8Char cannot be empty.
+    Empty,
+}
+use self::FromStrError::*;
+impl Error for FromStrError {
+    fn description(&self) -> &'static str {match *self {
+        SeveralCodePoints => "has more than one codepoint",
+        Empty => "is empty",
+    }}
+}
+impl Display for FromStrError {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}", self.description())
+    }
+}
+
+
+
+/// Reasons why an u32 is not a valid utf codepoint.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidCodePoint {
+    /// It's reserved for utf-16 surrogate pairs.
+    Utf16Reserved,
+    /// It's higher than the highest codepoint of 0x10ffff.
+    TooHigh,
+}
+use self::InvalidCodePoint::*;
+impl InvalidCodePoint {
+    /// Get the range of values for which this error would be given.
+    pub fn error_range(self) -> (u32,u32) {match self {
+        Utf16Reserved => (0xd8_00, 0xdf_ff),
+        TooHigh => (0x00_10_ff_ff, 0xff_ff_ff_ff),
+    }}
+}
+impl Error for InvalidCodePoint {
+    fn description(&self) -> &'static str {match *self {
+        Utf16Reserved => "is reserved for utf-16 surrogate pairs",
+        TooHigh => "is higher than the highest codepoint of 0x10ffff",
+    }}
+}
+impl Display for InvalidCodePoint {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}", self.description())
+    }
+}
+
+
+
+/// Reasons why a byte is not the start of a UTF-8 codepoint.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidUtf8FirstByte {
+    /// Sequences cannot be longer than 4 bytes. Is given for bytes >= 240.
+    TooLongSeqence,
+    /// This byte belongs to a previous seqence. Is given for values between 128 and 192 (exclusive).
+    ContinuationByte,
+}
+use self::InvalidUtf8FirstByte::*;
+impl Error for InvalidUtf8FirstByte {
+    fn description(&self) -> &'static str {match *self {
+        TooLongSeqence => "is greater than 239 (UTF-8 seqences cannot be longer than four bytes)",
+        ContinuationByte => "is a continuation of a previous sequence",
+    }}
+}
+impl Display for InvalidUtf8FirstByte {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}", self.description())
+    }
+}
+
+
+/// Reasons why a byte sequence is not valid UTF-8, excluding invalid codepoint.
+/// In sinking precedence.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidUtf8 {
+    /// Something is certainly wrong with the first byte.
+    FirstByte(InvalidUtf8FirstByte),
+    /// One of the continuation bytes doesnt fit the pattern 0b10xx_xxxx.
+    NotAContinuationByte(usize),
+    /// There are too many leading zeros; it could be a byte shorter.
+    OverLong,
+}
+use self::InvalidUtf8::*;
+impl Error for InvalidUtf8 {
+    fn description(&self) -> &'static str {match *self {
+        FirstByte(TooLongSeqence) => "the first byte is greater than 239 (UTF-8 seqences cannot be longer than four bytes)",
+        FirstByte(ContinuationByte) => "the first byte is a continuation of a previous sequence",
+        OverLong => "the seqence contains too many zeros and could be shorter",
+        NotAContinuationByte(_) => "the sequence is too short",
+    }}
+    /// When `Some` is returned, the `Error` is a `InvalidUtf8FirstByte`.
+    fn cause(&self) -> Option<&Error> {match *self {
+        FirstByte(ref cause) => Some(cause),
+        _ => None,
+    }}
+}
+impl Display for InvalidUtf8 {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}", self.description())
+    }
+}
+
+
+/// Reasons why a byte array is not valid UTF-8, in sinking precedence.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidUtf8Array {
+    /// Something is certainly wrong with the first byte.
+    Utf8(InvalidUtf8),
+    /// The encoded codepoint is invalid:
+    CodePoint(InvalidCodePoint),
+}
+impl Error for InvalidUtf8Array {
+    fn description(&self) -> &'static str {match *self {
+        InvalidUtf8Array::Utf8(_) => "the seqence is invalid UTF-8",
+        InvalidUtf8Array::CodePoint(_) => "the encoded codepoint is invalid",
+    }}
+    /// Always returns `Some`.
+    fn cause(&self) -> Option<&Error> {match *self {
+        InvalidUtf8Array::Utf8(ref u) => Some(u),
+        InvalidUtf8Array::CodePoint(ref c) => Some(c),
+    }}
+}
+impl Display for InvalidUtf8Array {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}: {}", self.description(), self.cause().unwrap().description())
+    }
+}
+
+
+/// Reasons why a byte slice is not valid UTF-8, in sinking precedence.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidUtf8Slice {
+    /// Something is certainly wrong with the first byte.
+    Utf8(InvalidUtf8),
+    /// The encoded codepoint is invalid:
+    CodePoint(InvalidCodePoint),
+    /// The slice is too short; n bytes was required.
+    TooShort(usize),
+}
+impl Error for InvalidUtf8Slice {
+    fn description(&self) -> &'static str {match *self {
+        InvalidUtf8Slice::Utf8(_) => "the seqence is invalid UTF-8",
+        InvalidUtf8Slice::CodePoint(_) => "the encoded codepoint is invalid",
+        InvalidUtf8Slice::TooShort(0) => "the slice is empty",
+        InvalidUtf8Slice::TooShort(_) => "the slice is shorter than the seqence",
+    }}
+    fn cause(&self) -> Option<&Error> {match *self {
+        InvalidUtf8Slice::Utf8(ref u) => Some(u),
+        InvalidUtf8Slice::CodePoint(ref c) => Some(c),
+        InvalidUtf8Slice::TooShort(_) => None,
+    }}
+}
+impl Display for InvalidUtf8Slice {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        match self.cause() {
+            Some(d) => write!(fmtr, "{}: {}", self.description(), d),
+            None    => write!(fmtr, "{}", self.description()),
+        }
+    }
+}
+
+
+
+/// Reasons why one or two `u16`s are not valid UTF-16, in sinking precedence.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidUtf16Tuple {
+    /// The first unit is a trailing/low surrogate, which is never valid.
+    ///
+    /// Note that the value of a low surrogate is actually higher than a high surrogate.
+    FirstIsTrailingSurrogate,
+    /// You provided a second unit, but the first one stands on its own.
+    SuperfluousSecond,
+    /// The first and only unit requires a second unit.
+    MissingSecond,
+    /// The first unit requires a second unit, but it's not a trailing/low surrogate.
+    ///
+    /// Note that the value of a low surrogate is actually higher than a high surrogate.
+    InvalidSecond,
+}
+impl Error for InvalidUtf16Tuple {
+    fn description(&self) -> &'static str {match *self {
+        InvalidUtf16Tuple::FirstIsTrailingSurrogate => "the first unit is a trailing / low surrogate, which is never valid",
+        InvalidUtf16Tuple::SuperfluousSecond => "the second unit is superfluous",
+        InvalidUtf16Tuple::MissingSecond => "the first unit requires a second unit",
+        InvalidUtf16Tuple::InvalidSecond => "the required second unit is not a trailing / low surrogate",
+    }}
+}
+impl Display for InvalidUtf16Tuple {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}", self.description())
+    }
+}
+
+
+/// Reasons why a slice of `u16`s doesn't start with valid UTF-16.
+#[derive(Clone,Copy, Debug, PartialEq,Eq)]
+pub enum InvalidUtf16Slice {
+    /// The slice is empty.
+    EmptySlice,
+    /// The first unit is a low surrogate.
+    FirstLowSurrogate,
+    /// The first and only unit requires a second unit.
+    MissingSecond,
+    /// The first unit requires a second one, but it's not a low surrogate.
+    SecondNotLowSurrogate,
+}
+impl Error for InvalidUtf16Slice {
+    fn description(&self) -> &'static str {match *self {
+        InvalidUtf16Slice::EmptySlice => "the slice is empty",
+        InvalidUtf16Slice::FirstLowSurrogate => "the first unit is a low surrogate",
+        InvalidUtf16Slice::MissingSecond => "the first and only unit requires a second one",
+        InvalidUtf16Slice::SecondNotLowSurrogate => "the required second unit is not a low surrogate",
+    }}
+}
+impl Display for InvalidUtf16Slice {
+    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
+        write!(fmtr, "{}", self.description())
+    }
+}
diff --git a/rustc_deps/vendor/encode_unicode/src/lib.rs b/rustc_deps/vendor/encode_unicode/src/lib.rs
new file mode 100644
index 0000000..ceada56
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/lib.rs
@@ -0,0 +1,46 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+
+//! Alternative and extension to the unstable `char.encode_utf8()` and `char.encode_utf16()`.
+
+
+// warnings
+#![warn(missing_docs)]
+#![cfg_attr(feature="clippy", feature(plugin))]
+#![cfg_attr(feature="clippy", plugin(clippy))]
+#![cfg_attr(feature="clippy", allow(len_without_is_empty))]// UtfxChar is never empty
+#![cfg_attr(feature="clippy", allow(match_same_arms))]
+#![cfg_attr(feature="clippy", allow(derive_hash_xor_eq))]// tested
+// precedence: I prefer spaces to parentheses, but it's nice to recheck.
+
+#![cfg_attr(feature="ascii", feature(ascii))]// one is a crate, the other is a std feature
+
+mod errors;
+mod traits;
+mod utf8_char;
+mod utf8_iterator;
+mod utf16_char;
+mod utf16_iterator;
+
+pub use traits::CharExt;
+pub use utf8_char::Utf8Char;
+pub use utf16_char::Utf16Char;
+pub use utf8_iterator::Utf8Iterator;
+pub use utf16_iterator::Utf16Iterator;
+pub use traits::U8UtfExt;
+pub use traits::U16UtfExt;
+
+pub mod error {// keeping the public interface in one file
+    //! Errors returned by various conversion methods in this crate.
+    pub use utf8_char::FromStrError;
+    pub use errors::{InvalidCodePoint};
+    pub use errors::{InvalidUtf8FirstByte,InvalidUtf8};
+    pub use errors::{InvalidUtf8Slice,InvalidUtf16Slice};
+    pub use errors::{InvalidUtf8Array,InvalidUtf16Tuple};
+}
diff --git a/rustc_deps/vendor/encode_unicode/src/traits.rs b/rustc_deps/vendor/encode_unicode/src/traits.rs
new file mode 100644
index 0000000..3850e52
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/traits.rs
@@ -0,0 +1,370 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+#![allow(unused_unsafe)]// explicit unsafe{} blocks in unsafe functions are a good thing.
+
+use Utf8Char;
+use Utf16Char;
+use Utf8Iterator;
+use Utf16Iterator;
+use error::*;
+extern crate std;
+use std::{char,u32, mem};
+use std::ops::Not;
+
+// TODO better docs and tests
+
+/// Methods for working with `u8`s UTF-8.
+pub trait U8UtfExt {
+    /// How many more bytes will you need to complete this codepoint?
+    /// Failures:
+    ///
+    /// * `128..192`: ContinuationByte
+    /// * `240..`: TooLongSequence
+    fn extra_utf8_bytes(self) -> Result<usize,InvalidUtf8FirstByte>;
+
+    /// How many more bytes will you need to complete this codepoint?
+    /// Assumes that self is a valid UTF-8 start.
+    /// Returns `self.not().leading_zeros().saturating_sub(1)`
+    fn extra_utf8_bytes_unchecked(self) -> usize;
+}
+
+impl U8UtfExt for u8 {
+    fn extra_utf8_bytes(self) -> Result<usize,InvalidUtf8FirstByte> {
+        use error::InvalidUtf8FirstByte::{ContinuationByte,TooLongSeqence};
+        match self.not().leading_zeros() {
+            0           =>  Ok(0),// ascii
+            1           =>  Err(ContinuationByte),// following byte
+            n if n < 5  =>  Ok(n as usize-1),// start of multibyte
+            _           =>  Err(TooLongSeqence),// too big
+        }
+    }
+    fn extra_utf8_bytes_unchecked(self) -> usize {
+        (self.not().leading_zeros()as usize).saturating_sub(1)
+    }
+}
+
+
+/// Methods for working with `u16`s as UTF-16 units.
+pub trait U16UtfExt {
+    /// Will you need an extra unit to complete this codepoint?
+    ///
+    /// # Failures:
+    ///
+    /// 0xdc00..0xe000
+    fn utf16_needs_extra_unit(self) -> Option<bool>;
+
+    /// Does this `u16` need another `u16` to complete a codepoint?
+    /// Returns `(self & 0xfc00) == 0xd800`
+    fn utf16_is_leading_surrogate(self) -> bool;
+}
+impl U16UtfExt for u16 {
+    fn utf16_needs_extra_unit(self) -> Option<bool> {match self {
+        // https://en.wikipedia.org/wiki/UTF-16#U.2B10000_to_U.2B10FFFF
+        0x_dc_00...0x_df_ff => None,
+        0x_d8_00...0x_db_ff => Some(true),
+        _                   => Some(false),
+    }}
+
+    fn utf16_is_leading_surrogate(self) -> bool {
+        (self & 0xfc00) == 0xd800// Clear the ten content bytes of a surrogate,
+                                 // and see if it's a leading surrogate.
+    }
+}
+
+
+
+
+/// Extension trait for `char` that adds methods for converting to and from UTF-8 or UTF-16.
+pub trait CharExt: Sized {
+    /// Get the UTF-8 representation of this codepoint.
+    ///
+    /// `Utf8Char` is to `[u8;4]` what `char` is to `u32`:
+    /// a restricted type that cannot be mutated internally.
+    fn to_utf8(self) -> Utf8Char;
+
+    /// Get the UTF-16 representation of this codepoint.
+    ///
+    /// `Utf16Char` is to `(u16,Option<u16>)` what `char` is to `u32`:
+    /// a restricted type that cannot be mutated internally.
+    fn to_utf16(self) -> Utf16Char;
+
+    /// Iterate over or [read](https://doc.rust-lang.org/std/io/trait.Read.html)
+    /// the one to four bytes in the UTF-8 representation of this codepoint.
+    fn iter_utf8_bytes(self) -> Utf8Iterator;
+
+    /// Iterate over the one or two units in the UTF-16 representation of this codepoint.
+    fn iter_utf16_units(self) -> Utf16Iterator;
+
+
+    /// Convert this char to UTF-8, and then
+    /// returns the number of bytes written.
+    ///
+    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
+    /// A buffer of length four is always large enough.
+    ///
+    /// Similar to the unstable `.encode_utf8()`,
+    /// but that method somehow still exist on stable, so I have to use a different name.
+    fn to_utf8_slice(self,  dst: &mut[u8]) -> Option<usize>;
+
+    /// Convert this char to UTF-16, and then
+    /// returns the number of units written.
+    ///
+    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
+    /// A buffer of length two is always large enough.
+    ///
+    /// Similar to the unstable `.encode_utf16()`,
+    /// but that method somehow still exist on stable, so I have to use a different name.
+    fn to_utf16_slice(self,  dst: &mut[u16]) -> Option<usize>;
+
+
+    /// Convert this char to an UTF-8 array and lenght,
+    /// The returned array is left-aligned, and the usize is how many bytes are used.
+    /// The unused bytes are zero.
+    fn to_utf8_array(self) -> ([u8; 4], usize);
+
+    /// Convert this char to UTF-16.
+    /// The second `u16` is `Some` if a surrogate pair is required.
+    fn to_utf16_tuple(self) -> (u16, Option<u16>);
+
+
+
+    /// Create a `char` from the start of a slice intepreted as UTF-8, and return how many bytes were needed.
+    fn from_utf8_slice(src: &[u8]) -> Result<(Self,usize),InvalidUtf8Slice>;
+
+    /// Read one or two UTF-16 units into a `char`, and also return how many units were needed.
+    fn from_utf16_slice(src: &[u16]) -> Result<(Self,usize), InvalidUtf16Slice>;
+
+
+    /// Convert an UTF-8 sequence as returned from `.to_utf8_array()` into a `char`
+    fn from_utf8_array(utf8: [u8; 4]) -> Result<Self,InvalidUtf8Array>;
+
+    /// Convert a UTF-16 pair as returned from `.to_utf16_tuple()` into a `char`.
+    fn from_utf16_tuple(utf16: (u16, Option<u16>)) -> Result<Self, InvalidUtf16Tuple>;
+
+
+    /// Convert an UTF-8 sequence into a char.
+    /// The length of the slice is the length of the sequence, should be 1,2,3 or 4.
+    ///
+    /// # Panics:
+    ///
+    /// If the slice is empty
+    unsafe fn from_utf8_exact_slice_unchecked(src: &[u8]) -> Self;
+
+    /// Convert a UTF-16 tuple as returned from `.to_utf16_tuple()` into a `char`.
+    unsafe fn from_utf16_tuple_unchecked(utf16: (u16, Option<u16>)) -> Self;
+
+
+    /// Perform some extra validations compared to `char::from_u32_unchecked()`
+    ///
+    /// # Failures:
+    ///
+    /// * the value is greater than 0x10ffff
+    /// * the value is between 0xd800 and 0xdfff (inclusive)
+    fn from_u32_detailed(c: u32) -> Result<Self,InvalidCodePoint>;
+}
+
+
+
+impl CharExt for char {
+      /////////
+     //UTF-8//
+    /////////
+
+    fn to_utf8(self) -> Utf8Char {
+        self.into()
+    }
+    fn iter_utf8_bytes(self) -> Utf8Iterator {
+        self.to_utf8().into_iter()
+    }
+    fn to_utf8_slice(self,  dst: &mut[u8]) -> Option<usize> {
+        self.to_utf8().to_slice(dst)
+    }
+
+    fn to_utf8_array(self) -> ([u8; 4], usize) {
+        let len = self.len_utf8();
+        let mut c = self as u32;
+        if len == 1 {// ASCII, the common case
+            ([c as u8, 0, 0, 0],  1)
+        } else {
+            let mut parts = 0;// convert to 6-bit bytes
+                        parts |= c & 0x3f;  c>>=6;
+            parts<<=8;  parts |= c & 0x3f;  c>>=6;
+            parts<<=8;  parts |= c & 0x3f;  c>>=6;
+            parts<<=8;  parts |= c & 0x3f;
+            parts |= 0x80_80_80_80;// set the most significant bit
+            parts >>= 8*(4-len);// right-align bytes
+            // Now, unused bytes are zero, (which matters for Utf8Char.eq()) and the rest are 0b10xx_xxxx
+
+            // set header on first byte
+            parts |= (0xff_00u32 >> len)  &  0xff;// store length
+            parts &= Not::not(1u32 << 7-len);// clear the next bit after it
+
+            let bytes: [u8; 4] = unsafe{ mem::transmute(u32::from_le(parts)) };
+            (bytes, len)
+        }
+    }
+
+
+    fn from_utf8_slice(src: &[u8]) -> Result<(Self,usize),InvalidUtf8Slice> {
+        use errors::InvalidUtf8::*;
+        use errors::InvalidUtf8Slice::*;
+        let first = *try!(src.first().ok_or(TooShort(1)));
+        let extra = try!(first.extra_utf8_bytes().map_err(|e| Utf8(FirstByte(e)) ));
+        if extra == 0 {
+            return Ok((first as char, 1));
+        } else if src.len() <= extra {
+            return Err(TooShort(extra+1))
+        }
+        let src = &src[..1+extra];
+        for (i, &b) in src.iter().enumerate().skip(1) {
+            if b < 0b1000_0000  ||  b > 0b1011_1111 {
+                return Err(Utf8(NotAContinuationByte(i)));
+            }
+        }
+        if overlong(src[0], src[1]) {
+            return Err(Utf8(OverLong));
+        }
+        let c = unsafe{ char::from_utf8_exact_slice_unchecked(src) };
+        char::from_u32_detailed(c as u32).map(|c| (c,src.len()) ).map_err( CodePoint )
+    }
+
+    fn from_utf8_array(utf8: [u8; 4]) -> Result<Self,InvalidUtf8Array> {
+        use errors::InvalidUtf8::*;
+        use errors::InvalidUtf8Array::*;
+        let len = match utf8[0].extra_utf8_bytes() {
+            Ok(0)     =>  return Ok(utf8[0] as char),
+            Ok(l)     =>  l+1,
+            Err(err)  =>  return Err(Utf8(FirstByte(err))),
+        };
+        for (i, &b) in utf8[..len].iter().enumerate().skip(1) {
+            if b < 0b1000_0000  ||  b > 0b1011_1111 {
+                return Err(Utf8(NotAContinuationByte(i)));
+            }
+        }
+
+        if overlong(utf8[0], utf8[1]) {
+            return Err(Utf8(OverLong));
+        }
+        let c = unsafe{ char::from_utf8_exact_slice_unchecked(&utf8[..len]) };
+        char::from_u32_detailed(c as u32).map_err( CodePoint )
+    }
+
+    unsafe fn from_utf8_exact_slice_unchecked(src: &[u8]) -> Self {
+        if src.len() == 1 {
+            src[0] as char
+        } else {
+            let mut c = src[0] as u32 & (0xff >> 2+src.len()-1);
+            for b in &src[1..] {
+                c = (c << 6)  |  (b & 0b00111111) as u32;
+            }
+            unsafe{ char::from_u32_unchecked(c) }
+        }
+    }
+
+
+
+      //////////
+     //UTF-16//
+    //////////
+
+    fn to_utf16(self) -> Utf16Char {
+        Utf16Char::from(self)
+    }
+    fn iter_utf16_units(self) -> Utf16Iterator {
+        self.to_utf16().into_iter()
+    }
+
+    fn to_utf16_slice(self,  dst: &mut[u16]) -> Option<usize> {
+        let (first, second) = self.to_utf16_tuple();
+        match (dst.len(), second) {
+            (0, _)            =>  None,
+            (1, Some(_))      =>  None,
+            (_, Some(second)) => {dst[0] = first;
+                                  dst[1] = second;
+                                  Some(2)
+                                 },
+            (_, None)         => {dst[0] = first;
+                                  Some(1)
+                                 },
+        }
+    }
+
+    fn to_utf16_tuple(self) -> (u16, Option<u16>) {
+        let c = self as u32;
+        if c <= 0x_ff_ff {// single (or reserved, which we ignore)
+            (c as u16, None)
+        } else {// double (or too high, which we ignore)
+            let c = c - 0x_01_00_00;
+            let high = 0x_d8_00 + (c >> 10);
+            let low = 0x_dc_00 + (c & 0x_03_ff);
+            (high as u16,  Some(low as u16))
+        }
+    }
+
+
+    fn from_utf16_slice(src: &[u16]) -> Result<(Self,usize), InvalidUtf16Slice> {
+        use errors::InvalidUtf16Slice::*;
+        let first = *try!(src.first().ok_or(EmptySlice));
+        match (first.utf16_needs_extra_unit(), src.get(1).cloned()) {
+            (Some(false),              _            )  =>  Ok((1, None)),
+            (Some(true) ,  Some(0x_dc_00...0x_df_ff))  =>  Ok((2, Some(src[1]))),
+            (Some(true) ,  Some(         _         ))  =>  Err(SecondNotLowSurrogate),
+            (Some(true) ,  None                     )  =>  Err(MissingSecond),
+            (None       ,              _            )  =>  Err(FirstLowSurrogate),
+        }.map(|(len,second)| (unsafe{ char::from_utf16_tuple_unchecked((first,second)) }, len) )
+    }
+
+    fn from_utf16_tuple(utf16: (u16, Option<u16>)) -> Result<Self, InvalidUtf16Tuple> {
+        use errors::InvalidUtf16Tuple::*;
+        match utf16 {
+            (0x_00_00...0x_d7_ff, None) => Ok(()),// single
+            (0x_e0_00...0x_ff_ff, None) => Ok(()),// single
+            (0x_d8_00...0x_db_ff, Some(0x_dc_00...0x_df_ff)) => Ok(()),// correct surrogate pair
+            (0x_d8_00...0x_db_ff, Some(_)) => Err(InvalidSecond),
+            (0x_d8_00...0x_db_ff, None) => Err(MissingSecond),
+            (0x_dc_00...0x_df_ff, _) => Err(FirstIsTrailingSurrogate),
+            (_, Some(_)) => Err(SuperfluousSecond),// should be no second
+            (_, _) => unreachable!()
+        }.map(|_| unsafe{ char::from_utf16_tuple_unchecked(utf16) } )
+    }
+
+    unsafe fn from_utf16_tuple_unchecked(utf16: (u16, Option<u16>)) -> Self {
+        let mut c = utf16.0 as u32;
+        if let Some(second) = utf16.1 {
+            let high = (c-0x_d8_00) << 10;
+            let low = second as u32 - 0x_dc_00;
+            c = high | low;
+            c += 0x_01_00_00;
+        }
+        unsafe{ char::from_u32_unchecked(c) }
+    }
+
+
+    fn from_u32_detailed(c: u32) -> Result<Self,InvalidCodePoint> {
+        use errors::InvalidCodePoint::*;
+        match c {
+            // reserved for UTF-16 surrogate pairs
+            0xd8_00...0xdf_ff => Err(Utf16Reserved),
+            // too big
+            0x11_00_00...u32::MAX => Err(TooHigh),
+            _ => Ok(unsafe{ char::from_u32_unchecked(c) }),
+        }
+    }
+}
+
+
+// If all the data bits in the first byte are zero, the sequence might be longer than necessary
+// When you go up one byte, you gain 6-1 data bits, so if the five first are zero it's too long.
+// The first byte has 3 + (4-len) data bits, which we know are zero.
+// The first two bits in the second byte are 10, which gets shifted out.
+fn overlong(first: u8,  second: u8) -> bool {
+    let both = ((first as u16) << 8)  |  (second << 2) as u16;
+    let both = both << 1+both.not().leading_zeros();
+    both.leading_zeros() >= 5
+}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf16_char.rs b/rustc_deps/vendor/encode_unicode/src/utf16_char.rs
new file mode 100644
index 0000000..fd5446c
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/utf16_char.rs
@@ -0,0 +1,206 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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 Utf16Iterator;
+use CharExt;
+use errors::{InvalidUtf16Slice,InvalidUtf16Tuple};
+extern crate std;
+use std::{hash,fmt,cmp};
+use std::borrow::Borrow;
+use std::ops::Deref;
+
+#[cfg(feature="ascii")]
+use std::ascii::AsciiExt;
+#[cfg(feature="ascii")]
+extern crate ascii;
+#[cfg(feature="ascii")]
+use self::ascii::{Ascii,AsciiCast};
+
+
+// I don't think there is any good default value for char, but char does.
+#[derive(Default)]
+// char doesn't do anything more advanced than u32 for Eq/Ord, so we shouldn't either.
+// When it's a single unit, the second is zero, so Eq works.
+// Ord however, breaks on surrogate pairs.
+#[derive(PartialEq,Eq)]
+#[derive(Clone,Copy)]
+
+
+/// Store a `char` as UTF-16 so it can be borrowed as a slice
+///
+/// Size is identical to `char`.
+/// Cannot represent all 2^32-1 possible values, but can do all valid ones.
+pub struct Utf16Char {
+    units: [u16; 2],
+}
+
+
+  /////////////////////
+ //conversion traits//
+/////////////////////
+
+impl From<char> for Utf16Char {
+    fn from(c: char) -> Self {
+        let (first, second) = c.to_utf16_tuple();
+        Utf16Char{ units: [first, second.unwrap_or(0)] }
+    }
+}
+impl From<Utf16Char> for char {
+    fn from(uc: Utf16Char) -> char {
+        unsafe{ char::from_utf16_tuple_unchecked(uc.to_tuple()) }
+    }
+}
+impl IntoIterator for Utf16Char {
+    type Item=u16;
+    type IntoIter=Utf16Iterator;
+    /// Iterate over the units.
+    fn into_iter(self) -> Utf16Iterator {
+        Utf16Iterator::from(self)
+    }
+}
+
+
+  /////////////////
+ //getter traits//
+/////////////////
+impl AsRef<[u16]> for Utf16Char {
+    fn as_ref(&self) -> &[u16] {
+        &self.units[..self.len()]
+    }
+}
+impl Borrow<[u16]> for Utf16Char {
+    fn borrow(&self) -> &[u16] {
+        self.as_ref()
+    }
+}
+impl Deref for Utf16Char {
+    type Target = [u16];
+    fn deref(&self) -> &[u16] {
+        self.as_ref()
+    }
+}
+
+
+  ////////////////
+ //ascii traits//
+////////////////
+#[cfg(feature="ascii")]
+/// Requires feature "ascii".
+impl AsciiExt for Utf16Char {
+    type Owned = Self;
+    fn is_ascii(&self) -> bool {
+        self.units[0] < 0x80
+    }
+    fn eq_ignore_ascii_case(&self,  other: &Self) -> bool {
+        self.to_char().eq_ignore_ascii_case(&other.to_char())
+    }
+    fn to_ascii_uppercase(&self) -> Self {
+        self.to_char().to_ascii_uppercase().to_utf16()
+    }
+    fn to_ascii_lowercase(&self) -> Self {
+        self.to_char().to_ascii_lowercase().to_utf16()
+    }
+    // Theese methods are what prevents this from becoming stable
+    fn make_ascii_uppercase(&mut self) {
+        *self = self.to_ascii_uppercase()
+    }
+    fn make_ascii_lowercase(&mut self) {
+        *self = self.to_ascii_lowercase();
+    }
+}
+#[cfg(feature="ascii")]
+/// Requires feature "ascii".
+impl From<Ascii> for Utf16Char {
+    fn from(ac: Ascii) -> Self {
+        Utf16Char{ units: [ac.as_byte() as u16,0] }
+    }
+}
+#[cfg(feature="ascii")]
+/// Requires feature "ascii".
+impl<'a> AsciiCast<'a> for Utf16Char {
+    type Target = Ascii;
+    unsafe fn to_ascii_nocheck(&'a self) -> Ascii {
+        (self.units[0] as u8).to_ascii_nocheck()
+    }
+}
+
+
+  /////////////////////////////////////////////////////////
+ //Genaral traits that cannot be derived to emulate char//
+/////////////////////////////////////////////////////////
+impl hash::Hash for Utf16Char {
+    fn hash<H : hash::Hasher>(&self,  state: &mut H) {
+        self.to_char().hash(state);
+    }
+}
+impl fmt::Debug for Utf16Char {
+    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.to_char(), fmtr)
+    }
+}
+impl cmp::PartialOrd for Utf16Char {
+    fn partial_cmp(&self,  rhs: &Self) -> Option<cmp::Ordering> {
+        self.to_char().partial_cmp(&rhs.to_char())
+    }
+}
+impl cmp::Ord for Utf16Char {
+    fn cmp(&self,  rhs: &Self) -> cmp::Ordering {
+        self.to_char().cmp(&rhs.to_char())
+    }
+}
+
+
+  ///////////////////////////////////////////////////////
+ //pub impls that should be together for nicer rustdoc//
+///////////////////////////////////////////////////////
+impl Utf16Char {
+    /// Validate and store the first UTF-16 codepoint in the slice.
+    /// Also return how many units were needed.
+    pub fn from_slice(src: &[u16]) -> Result<(Self,usize),InvalidUtf16Slice> {
+        char::from_utf16_slice(src).map(
+            |(_,len)|  (Utf16Char{ units: [src[0], if len==2 {src[1]} else {0}] }, len)
+        )
+    }
+    /// Validate and store a UTF-16 pair as returned from `char.to_utf16_tuple()`.
+    pub fn from_tuple(utf16: (u16,Option<u16>)) -> Result<Self,InvalidUtf16Tuple> {
+        char::from_utf16_tuple(utf16).map(
+            |_| Utf16Char{ units: [utf16.0, utf16.1.unwrap_or(0)] }
+        )
+    }
+
+    /// Returns 1 or 2.
+    /// There is no `.is_emty()` because it would always return false.
+    pub fn len(self) -> usize {
+        if self.units[1] == 0 {1} else {2}
+    }
+
+    /// Convert from UTF-16 to UTF-32
+    pub fn to_char(self) -> char {
+        self.into()
+    }
+    /// Write the internal representation to a slice,
+    /// and then returns the number of `u16`s written.
+    ///
+    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
+    /// A buffer of length two is always large enough.
+    pub fn to_slice(self,  dst: &mut[u16]) -> Option<usize> {
+        if self.len() <= dst.len() {
+            dst[0] = self.units[0];
+            if self.len() == 2 {
+                dst[1] = self.units[1];
+            }
+            Some(self.len())
+        } else {
+            None
+        }
+    }
+    /// The second `u16` is used for surrogate pairs.
+    pub fn to_tuple(self) -> (u16,Option<u16>) {
+        (self.units[0],  if self.len()==2 {Some(self.units[1])} else {None})
+    }
+}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf16_iterator.rs b/rustc_deps/vendor/encode_unicode/src/utf16_iterator.rs
new file mode 100644
index 0000000..5354a27
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/utf16_iterator.rs
@@ -0,0 +1,61 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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 CharExt;
+use Utf16Char;
+extern crate std;
+use std::fmt;
+
+
+/// Iterate over the units in an UTF-16 representation of a codepoint.
+#[derive(Clone,Copy)]
+pub struct Utf16Iterator {
+    first: Option<u16>,
+    second: Option<u16>,
+}
+impl From<char> for Utf16Iterator {
+    fn from(c: char) -> Self {
+        let (first, second) = c.to_utf16_tuple();
+        Utf16Iterator{ first: Some(first),  second: second }
+    }
+}
+impl From<Utf16Char> for Utf16Iterator {
+    fn from(uc: Utf16Char) -> Self {
+        let (first, second) = uc.to_tuple();
+        Utf16Iterator{ first: Some(first),  second: second }
+    }
+}
+impl Iterator for Utf16Iterator {
+    type Item=u16;
+    fn next(&mut self) -> Option<u16> {
+        match (self.first, self.second) {
+            (Some(first), _)     => {self.first = None;   Some(first) },
+            (None, Some(second)) => {self.second = None;  Some(second)},
+            (None, None)         => {                     None        },
+        }
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len(), Some(self.len()))
+    }
+}
+impl ExactSizeIterator for Utf16Iterator {
+    fn len(&self) -> usize {
+        match (self.first, self.second) {
+            (None   ,  None   )  =>  0,
+            (Some(_),  None   )  =>  1,
+            (None   ,  Some(_))  =>  1,
+            (Some(_),  Some(_))  =>  2,
+        }
+    }
+}
+impl fmt::Debug for Utf16Iterator {
+    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
+        let v: Vec<u16> = self.collect();
+        write!(fmtr, "{:?}", v)
+    }
+}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf8_char.rs b/rustc_deps/vendor/encode_unicode/src/utf8_char.rs
new file mode 100644
index 0000000..7624562
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/utf8_char.rs
@@ -0,0 +1,234 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+pub use errors::FromStrError;
+use error::{InvalidUtf8Slice,InvalidUtf8Array};
+use Utf8Iterator;
+use CharExt;
+use U8UtfExt;
+extern crate std;
+use std::{hash,fmt, str};
+use std::borrow::Borrow;
+use std::ops::Deref;
+use std::mem::transmute;
+
+#[cfg(feature="ascii")]
+use std::ascii::AsciiExt;
+#[cfg(feature="ascii")]
+extern crate ascii;
+#[cfg(feature="ascii")]
+use self::ascii::{Ascii,AsciiCast};
+
+
+// I don't think there is any good default value for char, but char does.
+#[derive(Default)]
+// char doesn't do anything more advanced than u32 for Eq/Ord, so we shouldn't either.
+// The default impl of Ord for arrays works out because longer codepoints
+//     start with more ones, so if they're equal, the length is the same,
+// breaks down for values above 0x1f_ff_ff but those can only be created by unsafe code.
+#[derive(PartialEq,Eq, PartialOrd,Ord)]
+
+#[derive(Clone,Copy)]
+
+
+/// Store a `char` as UTF-8 so it can be borrowed as a `str`
+///
+/// Has the same size as `char`, and is a `[u8;4]`
+/// with the invariant that the first nth bytes are valid UTF-8, and the remaining are zero.
+pub struct Utf8Char {
+    bytes: [u8; 4],
+}
+
+
+  /////////////////////
+ //conversion traits//
+/////////////////////
+impl str::FromStr for Utf8Char {
+    type Err = FromStrError;
+    /// The string must contain exactly one codepoint
+    fn from_str(s: &str) -> Result<Self, FromStrError> {
+        let mut uc = Utf8Char::default();
+        for (src, dst) in s.as_bytes().iter().zip(uc.bytes.iter_mut()) {
+            *dst = *src;// happens min(s.len(), 4) times
+        }
+        if uc.len() == s.len() {Ok(uc)}
+        else if s.is_empty()   {Err(FromStrError::Empty)}
+        else                   {Err(FromStrError::SeveralCodePoints)}
+    }
+}
+impl From<char> for Utf8Char {
+    fn from(c: char) -> Self {
+        Utf8Char{ bytes: c.to_utf8_array().0 }
+    }
+}
+impl From<Utf8Char> for char {
+    fn from(uc: Utf8Char) -> char {
+        unsafe{ char::from_utf8_exact_slice_unchecked(&uc.bytes[..uc.len()]) }
+    }
+}
+impl IntoIterator for Utf8Char {
+    type Item=u8;
+    type IntoIter=Utf8Iterator;
+    /// Iterate over the byte values.
+    fn into_iter(self) -> Utf8Iterator {
+        Utf8Iterator::from(self)
+    }
+}
+
+
+  /////////////////
+ //getter traits//
+/////////////////
+impl AsRef<[u8]> for Utf8Char {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes[..self.len()]
+    }
+}
+impl AsRef<str> for Utf8Char {
+    fn as_ref(&self) -> &str {
+        unsafe{ std::str::from_utf8_unchecked( self.as_ref() ) }
+    }
+}
+impl Borrow<[u8]> for Utf8Char {
+    fn borrow(&self) -> &[u8] {
+        self.as_ref()
+    }
+}
+impl Borrow<str> for Utf8Char {
+    fn borrow(&self) -> &str {
+        self.as_ref()
+    }
+}
+impl Deref for Utf8Char {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.as_ref()
+    }
+}
+
+
+  ////////////////
+ //ascii traits//
+////////////////
+#[cfg(feature="ascii")]
+/// Requires feature "ascii".
+impl AsciiExt for Utf8Char {
+    type Owned = Utf8Char;
+    fn is_ascii(&self) -> bool {
+        self.bytes[0].is_ascii()
+    }
+    fn eq_ignore_ascii_case(&self,  other: &Self) -> bool {
+        self.to_char().eq_ignore_ascii_case(&other.to_char())
+    }
+    fn to_ascii_uppercase(&self) -> Self::Owned {
+        let ascii = self.bytes[0].to_ascii_uppercase();
+        if ascii == self.bytes[0] {*self}
+        else {Utf8Char{ bytes: [ascii,0,0,0] }}
+    }
+    fn to_ascii_lowercase(&self) -> Self::Owned {
+        let ascii = self.bytes[0].to_ascii_lowercase();
+        if ascii == self.bytes[0] {*self}// unchanged
+        else {Utf8Char{ bytes: [ascii,0,0,0] }}// is ascii
+    }
+    // Theese methods are what prevents this from becoming stable
+    fn make_ascii_uppercase(&mut self) {
+        *self = self.to_ascii_uppercase()
+    }
+    fn make_ascii_lowercase(&mut self) {
+        *self = self.to_ascii_lowercase();
+    }
+}
+#[cfg(feature="ascii")]
+/// Requires feature "ascii".
+impl From<Ascii> for Utf8Char {
+    fn from(ac: Ascii) -> Self {
+        Utf8Char{ bytes: [ac.as_byte(),0,0,0] }
+    }
+}
+#[cfg(feature="ascii")]
+/// Requires feature "ascii".
+impl<'a> AsciiCast<'a> for Utf8Char {
+    type Target = Ascii;
+    unsafe fn to_ascii_nocheck(&'a self) -> Ascii {
+        self.bytes[0].to_ascii_nocheck()
+    }
+}
+
+
+  /////////////////////////////////////////////////////////
+ //Genaral traits that cannot be derived to emulate char//
+/////////////////////////////////////////////////////////
+impl hash::Hash for Utf8Char {
+    fn hash<H : hash::Hasher>(&self,  state: &mut H) {
+        self.to_char().hash(state);
+    }
+}
+impl fmt::Debug for Utf8Char {
+    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.to_char(), fmtr)
+    }
+}
+
+
+  ///////////////////////////////////////////////////////
+ //pub impls that should be together for nicer rustdoc//
+///////////////////////////////////////////////////////
+impl Utf8Char {
+    /// Validate the start of a UTF-8 slice and store it.
+    /// Also returns how many bytes were needed.
+    ///
+    /// If it's a str and you know it contains only one codepoint,
+    /// use `.from_str()` to skip the validation.
+    pub fn from_slice_start(src: &[u8]) -> Result<(Self,usize),InvalidUtf8Slice> {
+        // need to convert to char to check codepoint, but not convert back.
+        let len = try!(char::from_utf8_slice(src)).1;
+        let mut uc = Self::default();
+        for (dst, src) in uc.bytes.iter_mut().zip(src).take(len) {
+            *dst = *src;
+        }
+        Ok((uc,len))
+    }
+    /// Validate the array and store it.
+    pub fn from_array(utf8: [u8;4]) -> Result<Self,InvalidUtf8Array> {
+        try!(char::from_utf8_array(utf8));
+        let len = Utf8Char{ bytes: utf8 }.len() as u32;
+        let mask = u32::from_le(0xff_ff_ff_ff >> 8*(4-len));
+        let unused_zeroed = mask  &  unsafe{ transmute::<_,u32>(utf8) };
+        Ok(unsafe{ transmute(unused_zeroed) })
+    }
+
+    /// Result is 1...4 and identical to `.as_ref().len()` or `.as_char().len_utf8()`.
+    /// There is no .is_emty() because it would always return false.
+    pub fn len(self) -> usize {
+        self.bytes[0].extra_utf8_bytes_unchecked() + 1
+    }
+
+    /// Convert from UTF-8 to UTF-32
+    pub fn to_char(self) -> char {
+        self.into()
+    }
+    /// Write the internal representation to a slice,
+    /// and then returns the number of bytes written.
+    ///
+    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
+    /// A buffer of length four is always large enough.
+    pub fn to_slice(self,  dst: &mut[u8]) -> Option<usize> {
+        if self.len() <= dst.len() {
+            for (dst, src) in dst.iter_mut().zip(self.bytes.iter()) {
+                *dst  = *src;
+            }
+            Some(self.len())
+        } else {
+            None
+        }
+    }
+    /// Expose the internal array and the number of used bytes.
+    pub fn to_array(self) -> ([u8;4],usize) {
+        (self.bytes, self.len())
+    }
+}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf8_iterator.rs b/rustc_deps/vendor/encode_unicode/src/utf8_iterator.rs
new file mode 100644
index 0000000..5be3fd8
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/src/utf8_iterator.rs
@@ -0,0 +1,75 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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 Utf8Char;
+extern crate std;
+use std::{fmt,mem,u32,u64};
+use std::ops::Not;
+use std::io::{Read, Error as ioError};
+
+
+
+/// Read or iterate over the bytes in the UTF-8 representation of a codepoint.
+#[derive(Clone,Copy)]
+pub struct Utf8Iterator (u32);
+
+impl From<Utf8Char> for Utf8Iterator {
+    fn from(uc: Utf8Char) -> Self {
+        let used = u32::from_le(unsafe{ mem::transmute(uc) });
+        // uses u64 because shifting an u32 by 32 bits is a no-op.
+        let unused_set = (u64::MAX  <<  uc.len() as u64*8) as u32;
+        Utf8Iterator(used | unused_set)
+    }
+}
+impl From<char> for Utf8Iterator {
+    fn from(c: char) -> Self {
+        Self::from(Utf8Char::from(c))
+    }
+}
+impl Iterator for Utf8Iterator {
+    type Item=u8;
+    fn next(&mut self) -> Option<u8> {
+        let next = self.0 as u8;
+        if next == 0xff {
+            None
+        } else {
+            self.0 = (self.0 >> 8)  |  0xff_00_00_00;
+            Some(next)
+        }
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len(),  Some(self.len()))
+    }
+}
+impl ExactSizeIterator for Utf8Iterator {
+    fn len(&self) -> usize {// not straightforward, but possible
+        let unused_bytes = self.0.not().leading_zeros() / 8;
+        4 - unused_bytes as usize
+    }
+}
+impl Read for Utf8Iterator {
+    /// Always returns Ok
+    fn read(&mut self,  buf: &mut[u8]) -> Result<usize, ioError> {
+        let mut wrote = 0;
+        while let Some(ptr) = buf.get_mut(wrote) {// while loop because I need the counter afterwards
+            if let Some(b) = self.next() {// don't call self.next() untill I know I can write the result.
+                *ptr = b;
+                wrote += 1;
+            } else {
+                 break;
+            }
+        }
+        Ok(wrote)
+    }
+}
+impl fmt::Debug for Utf8Iterator {
+    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
+        let content: Vec<u8> = self.collect();
+        write!(fmtr, "bytes left: {:?}, content: {:x}", content, self.0)
+    }
+}
diff --git a/rustc_deps/vendor/encode_unicode/tests/fail_tests.rs b/rustc_deps/vendor/encode_unicode/tests/fail_tests.rs
new file mode 100644
index 0000000..735e75a
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/tests/fail_tests.rs
@@ -0,0 +1,97 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+#![feature(step_by)]
+//! Test that methods gives the correct error.
+//! Some also test a bit more because it's easy.
+
+use std::char;
+extern crate encode_unicode;
+use encode_unicode::*;
+use encode_unicode::error::*;
+
+
+#[test]
+fn from_u32() {
+    use encode_unicode::error::InvalidCodePoint::*;
+    for c in 0xd800..0xe000 {
+        assert_eq!(char::from_u32_detailed(c),  Err(Utf16Reserved));
+    }
+    for c in (0x110000..0xffffffff).step_by(0xfff) {
+        assert_eq!(char::from_u32_detailed(c),  Err(TooHigh));
+    }
+}
+
+#[test]
+fn utf8_extra_bytes() {
+    use encode_unicode::error::InvalidUtf8FirstByte::*;
+    for c in 0..256 {
+        assert_eq!( (c as u8).extra_utf8_bytes(), match c {
+            0b_1000_0000...0b_1011_1111 => Err(ContinuationByte),
+            0b_1111_1000...0b_1111_1111 => Err(TooLongSeqence),
+            0b_0000_0000...0b_0111_1111 => Ok(0),
+            0b_1100_0000...0b_1101_1111 => Ok(1),
+            0b_1110_0000...0b_1110_1111 => Ok(2),
+            0b_1111_0000...0b_1111_0111 => Ok(3),
+                         _              => unreachable!(),
+        });
+    }
+}
+
+#[test]
+fn utf16_extra_unit() {
+    for c in 0..0x1_00_00 {
+        assert_eq!( (c as u16).utf16_needs_extra_unit(), match c {
+            0b_0000_0000_0000_0000...0b_1101_0111_1111_1111 => Some(false),
+            0b_1101_1000_0000_0000...0b_1101_1011_1111_1111 => Some(true),
+            0b_1101_1100_0000_0000...0b_1101_1111_1111_1111 => None,
+            0b_1110_0000_0000_0000...0b_1111_1111_1111_1111 => Some(false),
+                                   _                        => unreachable!(),
+        });
+    }
+}
+
+
+#[test]
+fn from_utf16_tuple() {
+    use encode_unicode::error::InvalidUtf16Tuple::*;
+    for u in 0xdc00..0xe000 {
+        let close = if u%3==0 {u-100} else {u+100};
+        let doesnt_matter = if u%2==0 {Some(close)} else {None};
+	    assert_eq!(char::from_utf16_tuple((u,doesnt_matter)), Err(FirstIsTrailingSurrogate));
+    }
+    for u in (0..0xd800).chain(0xe000..0x10000) {
+        assert_eq!(char::from_utf16_tuple((u as u16,Some((0x100+u) as u16))), Err(SuperfluousSecond));
+	}
+    for u in 0xd800..0xdc00 {
+        assert_eq!(char::from_utf16_tuple((u,None)), Err(MissingSecond));
+
+	    assert_eq!(char::from_utf16_tuple((u,Some(u - 0x2ff))), Err(InvalidSecond));
+    }
+}
+
+#[test]
+fn overlong_utf8() {
+    use encode_unicode::error::InvalidUtf8::OverLong;
+    let overlongs = [[0xc0,0xbf], [0xe0,0x9f], [0xf0,0x8f],
+                     [0xc0,0x9f], [0xe0,0x8f], [0xf0,0x87]];
+    for o in overlongs.iter() {
+        let arr = [o[0],o[1], 0x80, 0x80];
+        assert_eq!(char::from_utf8_slice(&arr), Err(InvalidUtf8Slice::Utf8(OverLong)));
+        assert_eq!(char::from_utf8_array(arr), Err(InvalidUtf8Array::Utf8(OverLong)));
+    }
+}
+
+#[test]
+fn utf8_char_from_str() {
+    use std::str::FromStr;
+    use encode_unicode::error::FromStrError::*;
+    assert_eq!(Utf8Char::from_str(""), Err(Empty));
+    assert_eq!(Utf8Char::from_str("ab"), Err(SeveralCodePoints));
+    assert_eq!(Utf8Char::from_str("́e"), Err(SeveralCodePoints));// 'e'+u301 combining mark
+}
diff --git a/rustc_deps/vendor/encode_unicode/tests/iterator_tests.rs b/rustc_deps/vendor/encode_unicode/tests/iterator_tests.rs
new file mode 100644
index 0000000..1490785
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/tests/iterator_tests.rs
@@ -0,0 +1,31 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+//! iterators are stateful; test that they behave.
+
+use std::io::Read;
+extern crate encode_unicode;
+use encode_unicode::CharExt;
+//use encode_unicode::{Utf8Iterator,Utf16Iterator};
+
+#[test]
+fn read_single_byte() {
+    let mut buf = [0; 4];
+    for c in 0..128 {
+        let uc = char::from_u32_detailed(c).unwrap().to_utf8();
+        let mut iter = uc.into_iter();
+        assert_eq!((iter.read(&mut buf[..4]).unwrap(),c), (1,c));
+        assert_eq!((iter.read(&mut buf[..4]).unwrap(),c), (0,c));
+        let mut iter = uc.into_iter();
+        assert_eq!((iter.read(&mut buf[..1]).unwrap(),c), (1,c));
+        assert_eq!((iter.read(&mut buf[..1]).unwrap(),c), (0,c));
+        let mut iter = uc.into_iter();
+        assert_eq!((iter.read(&mut buf[..0]).unwrap(),c), (0,c));
+        assert_eq!((iter.read(&mut buf[..2]).unwrap(),c), (1,c));
+    }
+}
diff --git a/rustc_deps/vendor/encode_unicode/tests/pass_tests.rs b/rustc_deps/vendor/encode_unicode/tests/pass_tests.rs
new file mode 100644
index 0000000..e477938
--- /dev/null
+++ b/rustc_deps/vendor/encode_unicode/tests/pass_tests.rs
@@ -0,0 +1,147 @@
+/* Copyright 2016 Torbjørn Birch Moltu
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://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.
+ */
+
+#![feature(unicode)]// reference implementations of to_slice
+
+//! Test that every method gives the correct result for valid values.
+//! Except iterators, which are stateful.
+
+use std::char;
+use std::str::{self,FromStr};
+use std::hash::{Hash,SipHasher};
+extern crate encode_unicode;
+use encode_unicode::*;
+
+
+#[test]
+fn equal_defaults() {
+    assert_eq!(Utf8Char::default().to_char(), char::default());
+    assert_eq!(Utf16Char::default().to_char(), char::default());
+}
+
+#[test]
+fn same_size_as_char() {
+    use std::mem::size_of;
+    assert_eq!(size_of::<Utf8Char>(), size_of::<char>());
+    assert_eq!(size_of::<Utf16Char>(), size_of::<char>());
+}
+
+
+const EDGES_AND_BETWEEN: [u32;13] = [
+    0x0,// min
+    0x3b,// between
+    0x7f,// max 1-byte UTF-8
+    0x80,// min 2-byte UTF-8
+    0x111,// between
+    0x7ff,// max 2-byte UTF-8
+    0x800,// min 3-byte UTF-8
+    0xd7ff,// before reserved
+    0xe000,// after reserved
+    0xffff,// max UTF-16 single and 3-byte UTF-8
+    0x10000,// min UTF-16 surrogate and 4-byte UTF-8
+    0xabcde,// between
+    0x10ffff,// max
+];
+
+
+fn test(c: u32) {
+    let c = char::from_u32(c).expect(&format!("{:x} is not a valid char", c));
+    assert_eq!(char::from_u32_detailed(c as u32), Ok(c));
+    let sh = &mut SipHasher::new();
+
+    // UTF-8
+    let uc = c.to_utf8();
+    assert_eq!(uc.to_char(), c);
+    assert_eq!(uc.hash(sh), c.hash(sh));
+
+    let mut reference_dst = [0;4];
+    let mut len = None;
+    for i in 0..5 {
+        let mut test_dst = [0;4];
+        len = c.encode_utf8(&mut reference_dst[..i]);
+        assert_eq!(c.to_utf8_slice(&mut test_dst[..i]), len);
+        assert_eq!(test_dst, reference_dst);
+        assert_eq!(uc.to_slice(&mut test_dst[..i]), len);
+        assert_eq!(test_dst, reference_dst);
+    }
+    let len = len.expect(&format!("encode_utf8 never succeded: c={}={:x}, utf8={:?}", c, c as u32, reference_dst));
+    let str_ = str::from_utf8(&reference_dst[..len]).unwrap();
+    let ustr = Utf8Char::from_str(str_).unwrap();
+    assert_eq!(ustr.to_array().0, uc.to_array().0);// bitwise equality
+
+    assert_eq!(reference_dst[0].extra_utf8_bytes(), Ok(len-1));
+    assert_eq!(reference_dst[0].extra_utf8_bytes_unchecked(), len-1);
+    assert_eq!(c.to_utf8_array(),  (reference_dst, len));
+    assert_eq!(char::from_utf8_array(reference_dst), Ok(c));
+    assert_eq!(char::from_utf8_slice(&reference_dst[..len]), Ok((c,len)));
+    for other in &EDGES_AND_BETWEEN {
+        let other = unsafe{ char::from_u32_unchecked(*other) };
+        let uother = other.to_utf8();
+        assert_eq!(uc == uother,  c == other);
+        assert_eq!(uc.hash(sh)==other.hash(sh),  c.hash(sh)==uother.hash(sh));
+        assert_eq!(uc.cmp(&uother), c.cmp(&other));
+    }
+    assert_eq!(uc.to_array(),  (reference_dst, len));
+    assert_eq!(Utf8Char::from_array(reference_dst), Ok(uc));
+    assert_eq!(Utf8Char::from_slice_start(&reference_dst[..len]), Ok((uc,len)));
+    assert_eq!(c.iter_utf8_bytes().len(), len);
+    let iterated: Vec<_> = c.iter_utf8_bytes().collect();
+    assert_eq!(iterated[..], reference_dst[..len]);
+    assert_eq!(<AsRef<[u8]>>::as_ref(&uc), &iterated[..]);
+
+    // UTF-16
+    let uc = c.to_utf16();
+    assert_eq!(uc.to_char(), c);
+    assert_eq!(uc.hash(sh), c.hash(sh));
+    let mut reference_dst = [0;2];
+    let mut len = None;
+    for i in 0..3 {
+        let mut test_dst = [0;2];
+        len = c.encode_utf16(&mut reference_dst[..i]);
+        assert_eq!(c.to_utf16_slice(&mut test_dst[..i]), len);
+        assert_eq!(test_dst, reference_dst);
+        assert_eq!(uc.to_slice(&mut test_dst[..i]), len);
+        assert_eq!(test_dst, reference_dst);
+    }
+    let len = len.unwrap();
+    assert_eq!(reference_dst[0].utf16_needs_extra_unit(), Some(len==2));
+    assert_eq!(reference_dst[0].utf16_is_leading_surrogate(), len==2);
+    assert_eq!(char::from_utf16_slice(&reference_dst[..len]), Ok((c,len)));
+    for other in &EDGES_AND_BETWEEN {
+        let other = unsafe{ char::from_u32_unchecked(*other) };
+        let uother = other.to_utf16();
+        assert_eq!(uc == uother,  c == other);
+        assert_eq!(uc.hash(sh)==other.hash(sh),  c.hash(sh)==uother.hash(sh));
+        assert_eq!(uc.cmp(&uother), c.cmp(&other));
+    }
+    let tuple = c.to_utf16_tuple();
+    assert_eq!([tuple.0, tuple.1.unwrap_or(0)],  reference_dst);
+    assert_eq!(char::from_utf16_tuple(tuple), Ok(c));
+    assert_eq!(c.to_utf16().to_char(), c);
+    assert_eq!(c.iter_utf16_units().len(), len);
+    let iterated: Vec<_> = c.iter_utf16_units().collect();
+    assert_eq!(*iterated, reference_dst[0..len]);
+    assert_eq!(<AsRef<[u16]>>::as_ref(&uc), &iterated[..]);
+}
+
+
+#[test]
+fn edges_middle() {
+    for c in &EDGES_AND_BETWEEN {
+        test(*c);
+    }
+}
+
+
+#[test]
+#[ignore]
+fn all() {
+    for c in std::iter::Iterator::chain(0..0xd800, 0xe000..0x110000) {
+        test(c);
+    }
+}
diff --git a/rustc_deps/vendor/unicode-segmentation/.cargo-checksum.json b/rustc_deps/vendor/unicode-segmentation/.cargo-checksum.json
new file mode 100644
index 0000000..a3f544f
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{".travis.yml":"45a9e28a40dc51950223f939e74e09e3792d797db4c43c6a2e7d2ebc82e405e7","COPYRIGHT":"23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d","Cargo.toml":"f5cdd71581b22dd5aedcf9cc9d5b817cfc6df3163185b069b668a10c21912979","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0","README.md":"9fe1c77a06b34cbe0dca1bb987e7551a210d37287f517014345402c74d25eb1f","scripts/unicode.py":"4bbbbb274c358fa46eea130e99c7f77c1c2c4bb4f60f7380e77ac93e47a20143","scripts/unicode_gen_breaktests.py":"a8d9c88aec31f4d33b9850e71d497efbc9e6e9268a1b67ce55bd2a45ad552c67","src/grapheme.rs":"5b86f40dff85a539d80c5bdac496311295a5358a2558032111d4bec39767f15f","src/lib.rs":"445d37ea35cd787d8b5f43f853b74e4e21e374d65e78e45dbd77122bedf96b31","src/tables.rs":"a8fc42a3f3d788bf3154ee4012e9e90c1f311eba67ede3ff1d69fd4eb8cefe74","src/test.rs":"58d5d80e17df64a95c86728416afac0a4744adf5020bbbc053b2514ddeecd2da","src/testdata.rs":"33d4c58cf9416b342f31b1139b428676deecec34b0994c40ebe0c5cf4a639c79","src/word.rs":"eefecfcf85554fc529a44892fa7e3be50377b24a095610b7feb5f184c82818b9"},"package":"aa6024fc12ddfd1c6dbc14a80fa2324d4568849869b779f6bd37e5e4c03344d1"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/unicode-segmentation/.travis.yml b/rustc_deps/vendor/unicode-segmentation/.travis.yml
new file mode 100644
index 0000000..0e49a67
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/.travis.yml
@@ -0,0 +1,21 @@
+language: rust
+rust: stable
+os: linux
+script:
+  - cargo build --verbose
+  - cargo test --verbose
+  - rustdoc --test README.md -L target/debug -L target/debug/deps
+  - cargo doc
+after_success: |
+  [ $TRAVIS_BRANCH = master ] &&
+  [ $TRAVIS_PULL_REQUEST = false ] &&
+  echo '<meta http-equiv=refresh content=0;url=unicode_segmentation/index.html>' > target/doc/index.html &&
+  pip install ghp-import --user &&
+  $HOME/.local/bin/ghp-import -n target/doc &&
+  git push -qf https://${TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
+env:
+  global:
+    secure: d3xB8MAHhj88le5WjaDmIsharVeZ+eDIbQtuPEkg5VjIsD+ZOc9ZY/y1Nrz3q8Xh3ytjYv78IWmxwn8UsRhimCZbgR4V4xkz8hSgIGn9dFbOvIpbeg6Tfvu2UO2YUOcNc/WtI/uymaMuZ2g8Fcg7K2ITEO2lXAcOFRpnBh2dXmA=
+notifications:
+  email:
+    on_success: never
diff --git a/rustc_deps/vendor/unicode-segmentation/COPYRIGHT b/rustc_deps/vendor/unicode-segmentation/COPYRIGHT
new file mode 100644
index 0000000..b286ec1
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/COPYRIGHT
@@ -0,0 +1,7 @@
+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/rustc_deps/vendor/unicode-segmentation/Cargo.toml b/rustc_deps/vendor/unicode-segmentation/Cargo.toml
new file mode 100644
index 0000000..5b6e554
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/Cargo.toml
@@ -0,0 +1,29 @@
+# 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 believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "unicode-segmentation"
+version = "1.2.1"
+authors = ["kwantam <kwantam@gmail.com>"]
+exclude = ["target/*", "Cargo.lock", "scripts/tmp", "*.txt"]
+description = "This crate provides Grapheme Cluster and Word boundaries\naccording to Unicode Standard Annex #29 rules.\n"
+homepage = "https://github.com/unicode-rs/unicode-segmentation"
+documentation = "https://unicode-rs.github.io/unicode-segmentation"
+readme = "README.md"
+keywords = ["text", "unicode", "grapheme", "word", "boundary"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/unicode-rs/unicode-segmentation"
+[dev-dependencies.quickcheck]
+version = "0.4"
+
+[features]
+no_std = []
diff --git a/rustc_deps/vendor/unicode-segmentation/LICENSE-APACHE b/rustc_deps/vendor/unicode-segmentation/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              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/rustc_deps/vendor/unicode-segmentation/LICENSE-MIT b/rustc_deps/vendor/unicode-segmentation/LICENSE-MIT
new file mode 100644
index 0000000..e69282e
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/LICENSE-MIT
@@ -0,0 +1,25 @@
+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/rustc_deps/vendor/unicode-segmentation/README.md b/rustc_deps/vendor/unicode-segmentation/README.md
new file mode 100644
index 0000000..d1133c9
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/README.md
@@ -0,0 +1,67 @@
+Iterators which split strings on Grapheme Cluster or Word boundaries, according
+to the [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/) rules.
+
+[![Build Status](https://travis-ci.org/unicode-rs/unicode-segmentation.svg)](https://travis-ci.org/unicode-rs/unicode-segmentation)
+
+[Documentation](https://unicode-rs.github.io/unicode-segmentation/unicode_segmentation/index.html)
+
+```rust
+extern crate unicode_segmentation;
+
+use unicode_segmentation::UnicodeSegmentation;
+
+fn main() {
+    let s = "a̐éö̲\r\n";
+    let g = UnicodeSegmentation::graphemes(s, true).collect::<Vec<&str>>();
+    let b: &[_] = &["a̐", "é", "ö̲", "\r\n"];
+    assert_eq!(g, b);
+
+    let s = "The quick (\"brown\") fox can't jump 32.3 feet, right?";
+    let w = s.unicode_words().collect::<Vec<&str>>();
+    let b: &[_] = &["The", "quick", "brown", "fox", "can't", "jump", "32.3", "feet", "right"];
+    assert_eq!(w, b);
+
+    let s = "The quick (\"brown\")  fox";
+    let w = s.split_word_bounds().collect::<Vec<&str>>();
+    let b: &[_] = &["The", " ", "quick", " ", "(", "\"", "brown", "\"", ")", " ", " ", "fox"];
+    assert_eq!(w, b);
+}
+```
+
+# no_std
+
+unicode-segmentation does not depend on libstd, so it can be used in crates
+with the `#![no_std]` attribute.
+
+# crates.io
+
+You can use this package in your project by adding the following
+to your `Cargo.toml`:
+
+```toml
+[dependencies]
+unicode-segmentation = "1.1.0"
+```
+
+# Change Log
+
+## 1.2.0
+
+* New `GraphemeCursor` API allows random access and bidirectional iteration.
+* Fixed incorrect splitting of certain emoji modifier sequences.
+
+## 1.1.0
+
+* Add `as_str` methods to the iterator types.
+
+## 1.0.3
+
+* Code cleanup and additional tests.
+
+## 1.0.1
+
+* Fix a bug affecting some grapheme clusters containing Prepend characters.
+
+## 1.0.0
+
+* Upgrade to Unicode 9.0.0.
diff --git a/rustc_deps/vendor/unicode-segmentation/scripts/unicode.py b/rustc_deps/vendor/unicode-segmentation/scripts/unicode.py
new file mode 100755
index 0000000..189832b
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/scripts/unicode.py
@@ -0,0 +1,353 @@
+#!/usr/bin/env python
+#
+# Copyright 2011-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.
+
+# This script uses the following Unicode tables:
+# - DerivedCoreProperties.txt
+# - auxiliary/GraphemeBreakProperty.txt
+# - auxiliary/WordBreakProperty.txt
+# - ReadMe.txt
+# - UnicodeData.txt
+#
+# Since this should not require frequent updates, we just store this
+# out-of-line and check the unicode.rs file into git.
+
+import fileinput, re, os, sys, operator
+
+preamble = '''// 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.
+
+// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
+
+#![allow(missing_docs, non_upper_case_globals, non_snake_case)]
+'''
+
+# 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'],
+}
+
+# these are the surrogate codepoints, which are not valid rust characters
+surrogate_codepoints = (0xd800, 0xdfff)
+
+def is_surrogate(n):
+    return surrogate_codepoints[0] <= n <= surrogate_codepoints[1]
+
+def fetch(f):
+    if not os.path.exists(os.path.basename(f)):
+        os.system("curl -O http://www.unicode.org/Public/UNIDATA/%s"
+                  % f)
+
+    if not os.path.exists(os.path.basename(f)):
+        sys.stderr.write("cannot load %s" % f)
+        exit(1)
+
+def load_gencats(f):
+    fetch(f)
+    gencats = {}
+
+    udict = {};
+    range_start = -1;
+    for line in fileinput.input(f):
+        data = line.split(';');
+        if len(data) != 15:
+            continue
+        cp = int(data[0], 16);
+        if is_surrogate(cp):
+            continue
+        if range_start >= 0:
+            for i in xrange(range_start, cp):
+                udict[i] = data;
+            range_start = -1;
+        if data[1].endswith(", First>"):
+            range_start = cp;
+            continue;
+        udict[cp] = data;
+
+    for code in udict:
+        [code_org, name, gencat, combine, bidi,
+         decomp, deci, digit, num, mirror,
+         old, iso, upcase, lowcase, titlecase ] = udict[code];
+
+        # place letter in categories as appropriate
+        for cat in [gencat, "Assigned"] + expanded_categories.get(gencat, []):
+            if cat not in gencats:
+                gencats[cat] = []
+            gencats[cat].append(code)
+
+    gencats = group_cats(gencats)
+    return gencats
+
+def group_cats(cats):
+    cats_out = {}
+    for cat in cats:
+        cats_out[cat] = group_cat(cats[cat])
+    return cats_out
+
+def group_cat(cat):
+    cat_out = []
+    letters = sorted(set(cat))
+    cur_start = letters.pop(0)
+    cur_end = cur_start
+    for letter in letters:
+        assert letter > cur_end, \
+            "cur_end: %s, letter: %s" % (hex(cur_end), hex(letter))
+        if letter == cur_end + 1:
+            cur_end = letter
+        else:
+            cat_out.append((cur_start, cur_end))
+            cur_start = cur_end = letter
+    cat_out.append((cur_start, cur_end))
+    return cat_out
+
+def ungroup_cat(cat):
+    cat_out = []
+    for (lo, hi) in cat:
+        while lo <= hi:
+            cat_out.append(lo)
+            lo += 1
+    return cat_out
+
+def format_table_content(f, content, indent):
+    line = " "*indent
+    first = True
+    for chunk in content.split(","):
+        if len(line) + len(chunk) < 98:
+            if first:
+                line += chunk
+            else:
+                line += ", " + chunk
+            first = False
+        else:
+            f.write(line + ",\n")
+            line = " "*indent + chunk
+    f.write(line)
+
+def load_properties(f, interestingprops):
+    fetch(f)
+    props = {}
+    re1 = re.compile("^ *([0-9A-F]+) *; *(\w+)")
+    re2 = re.compile("^ *([0-9A-F]+)\.\.([0-9A-F]+) *; *(\w+)")
+
+    for line in fileinput.input(os.path.basename(f)):
+        prop = None
+        d_lo = 0
+        d_hi = 0
+        m = re1.match(line)
+        if m:
+            d_lo = m.group(1)
+            d_hi = m.group(1)
+            prop = m.group(2)
+        else:
+            m = re2.match(line)
+            if m:
+                d_lo = m.group(1)
+                d_hi = m.group(2)
+                prop = m.group(3)
+            else:
+                continue
+        if interestingprops and prop not in interestingprops:
+            continue
+        d_lo = int(d_lo, 16)
+        d_hi = int(d_hi, 16)
+        if prop not in props:
+            props[prop] = []
+        props[prop].append((d_lo, d_hi))
+
+    # optimize if possible
+    for prop in props:
+        props[prop] = group_cat(ungroup_cat(props[prop]))
+
+    return props
+
+def escape_char(c):
+    return "'\\u{%x}'" % c
+
+def emit_table(f, name, t_data, t_type = "&'static [(char, char)]", is_pub=True,
+        pfun=lambda x: "(%s,%s)" % (escape_char(x[0]), escape_char(x[1])), is_const=True):
+    pub_string = "const"
+    if not is_const:
+        pub_string = "let"
+    if is_pub:
+        pub_string = "pub " + pub_string
+    f.write("    %s %s: %s = &[\n" % (pub_string, name, t_type))
+    data = ""
+    first = True
+    for dat in t_data:
+        if not first:
+            data += ","
+        first = False
+        data += pfun(dat)
+    format_table_content(f, data, 8)
+    f.write("\n    ];\n\n")
+
+def emit_util_mod(f):
+    f.write("""
+pub mod util {
+    #[inline]
+    pub fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        r.binary_search_by(|&(lo,hi)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }).is_ok()
+    }
+
+    #[inline]
+    fn is_alphabetic(c: char) -> bool {
+        match c {
+            'a' ... 'z' | 'A' ... 'Z' => true,
+            c if c > '\x7f' => super::derived_property::Alphabetic(c),
+            _ => false,
+        }
+    }
+
+    #[inline]
+    fn is_numeric(c: char) -> bool {
+        match c {
+            '0' ... '9' => true,
+            c if c > '\x7f' => super::general_category::N(c),
+            _ => false,
+        }
+    }
+
+    #[inline]
+    pub fn is_alphanumeric(c: char) -> bool {
+        is_alphabetic(c) || is_numeric(c)
+    }
+}
+
+""")
+
+def emit_property_module(f, mod, tbl, emit):
+    f.write("mod %s {\n" % mod)
+    for cat in sorted(emit):
+        emit_table(f, "%s_table" % cat, tbl[cat], is_pub=False)
+        f.write("    #[inline]\n")
+        f.write("    pub fn %s(c: char) -> bool {\n" % cat)
+        f.write("        super::util::bsearch_range_table(c, %s_table)\n" % cat)
+        f.write("    }\n\n")
+    f.write("}\n\n")
+
+def emit_break_module(f, break_table, break_cats, name):
+    Name = name.capitalize()
+    f.write("""pub mod %s {
+    use core::result::Result::{Ok, Err};
+
+    pub use self::%sCat::*;
+
+    #[allow(non_camel_case_types)]
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub enum %sCat {
+""" % (name, Name, Name))
+
+    break_cats.append("Any")
+    break_cats.sort()
+    for cat in break_cats:
+        f.write(("        %sC_" % Name[0]) + cat + ",\n")
+    f.write("""    }
+
+    fn bsearch_range_value_table(c: char, r: &'static [(char, char, %sCat)]) -> %sCat {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        match r.binary_search_by(|&(lo, hi, _)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }) {
+            Ok(idx) => {
+                let (_, _, cat) = r[idx];
+                cat
+            }
+            Err(_) => %sC_Any
+        }
+    }
+
+    pub fn %s_category(c: char) -> %sCat {
+        bsearch_range_value_table(c, %s_cat_table)
+    }
+
+""" % (Name, Name, Name[0], name, Name, name))
+
+    emit_table(f, "%s_cat_table" % name, break_table, "&'static [(char, char, %sCat)]" % Name,
+        pfun=lambda x: "(%s,%s,%sC_%s)" % (escape_char(x[0]), escape_char(x[1]), Name[0], x[2]),
+        is_pub=False, is_const=True)
+    f.write("}\n")
+
+if __name__ == "__main__":
+    r = "tables.rs"
+    if os.path.exists(r):
+        os.remove(r)
+    with open(r, "w") as rf:
+        # write the file's preamble
+        rf.write(preamble)
+
+        # download and parse all the data
+        fetch("ReadMe.txt")
+        with open("ReadMe.txt") as readme:
+            pattern = "for Version (\d+)\.(\d+)\.(\d+) of the Unicode"
+            unicode_version = re.search(pattern, readme.read()).groups()
+        rf.write("""
+/// The version of [Unicode](http://www.unicode.org/)
+/// that this version of unicode-segmentation is based on.
+pub const UNICODE_VERSION: (u64, u64, u64) = (%s, %s, %s);
+""" % unicode_version)
+
+        gencats = load_gencats("UnicodeData.txt")
+        derived = load_properties("DerivedCoreProperties.txt", ["Alphabetic"])
+
+        emit_util_mod(rf)
+        for (name, cat, pfuns) in ("general_category", gencats, ["N"]), \
+                                  ("derived_property", derived, ["Alphabetic"]):
+            emit_property_module(rf, name, cat, pfuns)
+
+        ### grapheme cluster module
+        # from http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Break_Property_Values
+        grapheme_cats = load_properties("auxiliary/GraphemeBreakProperty.txt", [])
+
+        # Control
+        #  Note:
+        # This category also includes Cs (surrogate codepoints), but Rust's `char`s are
+        # Unicode Scalar Values only, and surrogates are thus invalid `char`s.
+        # Thus, we have to remove Cs from the Control category
+        grapheme_cats["Control"] = group_cat(list(
+            set(ungroup_cat(grapheme_cats["Control"]))
+            - set(ungroup_cat([surrogate_codepoints]))))
+
+        grapheme_table = []
+        for cat in grapheme_cats:
+            grapheme_table.extend([(x, y, cat) for (x, y) in grapheme_cats[cat]])
+        grapheme_table.sort(key=lambda w: w[0])
+        emit_break_module(rf, grapheme_table, grapheme_cats.keys(), "grapheme")
+        rf.write("\n")
+
+        word_cats = load_properties("auxiliary/WordBreakProperty.txt", [])
+        word_table = []
+        for cat in word_cats:
+            word_table.extend([(x, y, cat) for (x, y) in word_cats[cat]])
+        word_table.sort(key=lambda w: w[0])
+        emit_break_module(rf, word_table, word_cats.keys(), "word")
diff --git a/rustc_deps/vendor/unicode-segmentation/scripts/unicode_gen_breaktests.py b/rustc_deps/vendor/unicode-segmentation/scripts/unicode_gen_breaktests.py
new file mode 100755
index 0000000..476aa93
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/scripts/unicode_gen_breaktests.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python
+# -*- coding: utf-8
+#
+# Copyright 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.
+
+# This script uses the following Unicode tables:
+# - auxiliary/GraphemeBreakTest.txt
+# - auxiliary/WordBreakTest.txt
+#
+# Since this should not require frequent updates, we just store this
+# out-of-line and check the unicode.rs file into git.
+
+import unicode, re, os, fileinput
+
+def load_test_data(f, optsplit=[]):
+    outls = []
+    testRe1 = re.compile("^÷\s+([^\s].*[^\s])\s+÷\s+#\s+÷\s+\[0.2\].*?([÷×].*)\s+÷\s+\[0.3\]\s*$")
+
+    unicode.fetch(f)
+    data = []
+    for line in fileinput.input(os.path.basename(f)):
+        # lines that include a test start with the ÷ character
+        if len(line) < 2 or line[0:2] != '÷':
+            continue
+
+        m = testRe1.match(line)
+        if not m:
+            print "error: no match on line where test was expected: %s" % line
+            continue
+
+        # process the characters in this test case
+        chars = process_split_string(m.group(1))
+        # skip test case if it contains invalid characters (viz., surrogates)
+        if not chars:
+            continue
+
+        # now process test cases
+        (chars, info) = process_split_info(m.group(2), chars, optsplit)
+
+        # make sure that we have break info for each break!
+        assert len(chars) - 1 == len(info)
+
+        outls.append((chars, info))
+
+    return outls
+
+def process_split_info(s, c, o):
+    outcs = []
+    outis = []
+    workcs = c.pop(0)
+
+    # are we on a × or a ÷?
+    isX = False
+    if s[0:2] == '×':
+        isX = True
+
+    # find each instance of '(÷|×) [x.y] '
+    while s:
+        # find the currently considered rule number
+        sInd = s.index('[') + 1
+        eInd = s.index(']')
+
+        # if it's '× [a.b]' where 'a.b' is in o, then
+        # we consider it a split even though it's not
+        # marked as one
+        # if it's ÷ then it's always a split
+        if not isX or s[sInd:eInd] in o:
+            outis.append(s[sInd:eInd])
+            outcs.append(workcs)
+            workcs = c.pop(0)
+        else:
+            workcs.extend(c.pop(0))
+
+        idx = 1
+        while idx < len(s):
+            if s[idx:idx+2] == '×':
+                isX = True
+                break
+            if s[idx:idx+2] == '÷':
+                isX = False
+                break
+            idx += 1
+        s = s[idx:]
+
+    outcs.append(workcs)
+    return (outcs, outis)
+
+def process_split_string(s):
+    outls = []
+    workls = []
+
+    inls = s.split()
+
+    for i in inls:
+        if i == '÷' or i == '×':
+            outls.append(workls)
+            workls = []
+            continue
+
+        ival = int(i,16)
+
+        if unicode.is_surrogate(ival):
+            return []
+
+        workls.append(ival)
+
+    if workls:
+        outls.append(workls)
+
+    return outls
+
+def showfun(x):
+    outstr = '("'
+    for c in x[0]:
+        outstr += "\\u{%x}" % c
+    outstr += '",&['
+    xfirst = True
+    for xx in x[1:]:
+        if not xfirst:
+            outstr += '],&['
+        xfirst = False
+        sfirst = True
+        for sp in xx:
+            if not sfirst:
+                outstr += ','
+            sfirst = False
+            outstr += '"'
+            for c in sp:
+                outstr += "\\u{%x}" % c
+            outstr += '"'
+    outstr += '])'
+    return outstr
+
+def create_grapheme_data(f):
+    # rules 9.1 and 9.2 are for extended graphemes only
+    optsplits = ['9.1','9.2']
+    d = load_test_data("auxiliary/GraphemeBreakTest.txt", optsplits)
+
+    test_same = []
+    test_diff = []
+
+    for (c, i) in d:
+        allchars = [cn for s in c for cn in s]
+        extgraphs = []
+        extwork = []
+
+        extwork.extend(c[0])
+        for n in range(0,len(i)):
+            if i[n] in optsplits:
+                extwork.extend(c[n+1])
+            else:
+                extgraphs.append(extwork)
+                extwork = []
+                extwork.extend(c[n+1])
+
+        # these are the extended grapheme clusters
+        extgraphs.append(extwork)
+
+        if extgraphs == c:
+            test_same.append((allchars, c))
+        else:
+            test_diff.append((allchars, extgraphs, c))
+
+    stype = "&'static [(&'static str, &'static [&'static str])]"
+    dtype = "&'static [(&'static str, &'static [&'static str], &'static [&'static str])]"
+    f.write("    // official Unicode test data\n")
+    f.write("    // http://www.unicode.org/Public/UNIDATA/auxiliary/GraphemeBreakTest.txt\n")
+    unicode.emit_table(f, "TEST_SAME", test_same, stype, True, showfun, True)
+    unicode.emit_table(f, "TEST_DIFF", test_diff, dtype, True, showfun, True)
+
+def create_words_data(f):
+    d = load_test_data("auxiliary/WordBreakTest.txt")
+
+    test = []
+
+    for (c, i) in d:
+        allchars = [cn for s in c for cn in s]
+        test.append((allchars, c))
+
+    wtype = "&'static [(&'static str, &'static [&'static str])]"
+    f.write("    // official Unicode test data\n")
+    f.write("    // http://www.unicode.org/Public/UNIDATA/auxiliary/WordBreakTest.txt\n")
+    unicode.emit_table(f, "TEST_WORD", test, wtype, True, showfun, True)
+
+if __name__ == "__main__":
+    with open("testdata.rs", "w") as rf:
+        rf.write(unicode.preamble)
+        create_grapheme_data(rf)
+        create_words_data(rf)
diff --git a/rustc_deps/vendor/unicode-segmentation/src/grapheme.rs b/rustc_deps/vendor/unicode-segmentation/src/grapheme.rs
new file mode 100644
index 0000000..f6062f7
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/src/grapheme.rs
@@ -0,0 +1,704 @@
+// Copyright 2012-2014 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::cmp;
+
+use tables::grapheme::GraphemeCat;
+
+/// External iterator for grapheme clusters and byte offsets.
+#[derive(Clone)]
+pub struct GraphemeIndices<'a> {
+    start_offset: usize,
+    iter: Graphemes<'a>,
+}
+
+impl<'a> GraphemeIndices<'a> {
+    #[inline]
+    /// View the underlying data (the part yet to be iterated) as a slice of the original string.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::UnicodeSegmentation;
+    /// let mut iter = "abc".grapheme_indices(true);
+    /// assert_eq!(iter.as_str(), "abc");
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), "bc");
+    /// iter.next();
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), "");
+    /// ```
+    pub fn as_str(&self) -> &'a str {
+        self.iter.as_str()
+    }
+}
+
+impl<'a> Iterator for GraphemeIndices<'a> {
+    type Item = (usize, &'a str);
+
+    #[inline]
+    fn next(&mut self) -> Option<(usize, &'a str)> {
+        self.iter.next().map(|s| (s.as_ptr() as usize - self.start_offset, s))
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<'a> DoubleEndedIterator for GraphemeIndices<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<(usize, &'a str)> {
+        self.iter.next_back().map(|s| (s.as_ptr() as usize - self.start_offset, s))
+    }
+}
+
+/// External iterator for a string's
+/// [grapheme clusters](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries).
+#[derive(Clone)]
+pub struct Graphemes<'a> {
+    string: &'a str,
+    cursor: GraphemeCursor,
+    cursor_back: GraphemeCursor,
+}
+
+impl<'a> Graphemes<'a> {
+    #[inline]
+    /// View the underlying data (the part yet to be iterated) as a slice of the original string.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::UnicodeSegmentation;
+    /// let mut iter = "abc".graphemes(true);
+    /// assert_eq!(iter.as_str(), "abc");
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), "bc");
+    /// iter.next();
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), "");
+    /// ```
+    pub fn as_str(&self) -> &'a str {
+        &self.string[self.cursor.cur_cursor()..self.cursor_back.cur_cursor()]
+    }
+}
+
+impl<'a> Iterator for Graphemes<'a> {
+    type Item = &'a str;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let slen = self.cursor_back.cur_cursor() - self.cursor.cur_cursor();
+        (cmp::min(slen, 1), Some(slen))
+    }
+
+    #[inline]
+    fn next(&mut self) -> Option<&'a str> {
+        let start = self.cursor.cur_cursor();
+        if start == self.cursor_back.cur_cursor() {
+            return None;
+        }
+        let next = self.cursor.next_boundary(self.string, 0).unwrap().unwrap();
+        Some(&self.string[start..next])
+    }
+}
+
+impl<'a> DoubleEndedIterator for Graphemes<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a str> {
+        let end = self.cursor_back.cur_cursor();
+        if end == self.cursor.cur_cursor() {
+            return None;
+        }
+        let prev = self.cursor_back.prev_boundary(self.string, 0).unwrap().unwrap();
+        Some(&self.string[prev..end])
+    }
+}
+
+#[inline]
+pub fn new_graphemes<'b>(s: &'b str, is_extended: bool) -> Graphemes<'b> {
+    let len = s.len();
+    Graphemes {
+        string: s,
+        cursor: GraphemeCursor::new(0, len, is_extended),
+        cursor_back: GraphemeCursor::new(len, len, is_extended),
+    }
+}
+
+#[inline]
+pub fn new_grapheme_indices<'b>(s: &'b str, is_extended: bool) -> GraphemeIndices<'b> {
+    GraphemeIndices { start_offset: s.as_ptr() as usize, iter: new_graphemes(s, is_extended) }
+}
+
+// maybe unify with PairResult?
+// An enum describing information about a potential boundary.
+#[derive(PartialEq, Eq, Clone)]
+enum GraphemeState {
+    // No information is known.
+    Unknown,
+    // It is known to not be a boundary.
+    NotBreak,
+    // It is known to be a boundary.
+    Break,
+    // The codepoint after is a Regional Indicator Symbol, so a boundary iff
+    // it is preceded by an even number of RIS codepoints. (GB12, GB13)
+    Regional,
+    // The codepoint after is in the E_Modifier category, so whether it's a boundary
+    // depends on pre-context according to GB10.
+    Emoji,
+}
+
+/// Cursor-based segmenter for grapheme clusters.
+#[derive(Clone)]
+pub struct GraphemeCursor {
+    // Current cursor position.
+    offset: usize,
+    // Total length of the string.
+    len: usize,
+    // A config flag indicating whether this cursor computes legacy or extended
+    // grapheme cluster boundaries (enables GB9a and GB9b if set).
+    is_extended: bool,
+    // Information about the potential boundary at `offset`
+    state: GraphemeState,
+    // Category of codepoint immediately preceding cursor, if known.
+    cat_before: Option<GraphemeCat>,
+    // Category of codepoint immediately after cursor, if known.
+    cat_after: Option<GraphemeCat>,
+    // If set, at least one more codepoint immediately preceding this offset
+    // is needed to resolve whether there's a boundary at `offset`.
+    pre_context_offset: Option<usize>,
+    // The number of RIS codepoints preceding `offset`. If `pre_context_offset`
+    // is set, then counts the number of RIS between that and `offset`, otherwise
+    // is an accurate count relative to the string.
+    ris_count: Option<usize>,
+    // Set if a call to `prev_boundary` or `next_boundary` was suspended due
+    // to needing more input.
+    resuming: bool,
+}
+
+/// An error return indicating that not enough content was available in the
+/// provided chunk to satisfy the query, and that more content must be provided.
+#[derive(PartialEq, Eq, Debug)]
+pub enum GraphemeIncomplete {
+    /// More pre-context is needed. The caller should call `provide_context`
+    /// with a chunk ending at the offset given, then retry the query. This
+    /// will only be returned if the `chunk_start` parameter is nonzero.
+    PreContext(usize),
+
+    /// When requesting `prev_boundary`, the cursor is moving past the beginning
+    /// of the current chunk, so the chunk before that is requested. This will
+    /// only be returned if the `chunk_start` parameter is nonzero.
+    PrevChunk,
+
+    /// When requesting `next_boundary`, the cursor is moving past the end of the
+    /// current chunk, so the chunk after that is requested. This will only be
+    /// returned if the chunk ends before the `len` parameter provided on
+    /// creation of the cursor.
+    NextChunk,  // requesting chunk following the one given
+
+    /// An error returned when the chunk given does not contain the cursor position.
+    InvalidOffset,
+}
+
+// An enum describing the result from lookup of a pair of categories.
+#[derive(PartialEq, Eq)]
+enum PairResult {
+    NotBreak,  // definitely not a break
+    Break,  // definitely a break
+    Extended,  // a break iff not in extended mode
+    Regional,  // a break if preceded by an even number of RIS
+    Emoji,  // a break if preceded by emoji base and (Extend)*
+}
+
+fn check_pair(before: GraphemeCat, after: GraphemeCat) -> PairResult {
+    use tables::grapheme::GraphemeCat::*;
+    use self::PairResult::*;
+    match (before, after) {
+        (GC_CR, GC_LF) => NotBreak,  // GB3
+        (GC_Control, _) => Break,  // GB4
+        (GC_CR, _) => Break,  // GB4
+        (GC_LF, _) => Break,  // GB4
+        (_, GC_Control) => Break,  // GB5
+        (_, GC_CR) => Break,  // GB5
+        (_, GC_LF) => Break,  // GB5
+        (GC_L, GC_L) => NotBreak,  // GB6
+        (GC_L, GC_V) => NotBreak,  // GB6
+        (GC_L, GC_LV) => NotBreak,  // GB6
+        (GC_L, GC_LVT) => NotBreak,  // GB6
+        (GC_LV, GC_V) => NotBreak,  // GB7
+        (GC_LV, GC_T) => NotBreak,  // GB7
+        (GC_V, GC_V) => NotBreak,  // GB7
+        (GC_V, GC_T) => NotBreak,  // GB7
+        (GC_LVT, GC_T) => NotBreak,  // GB8
+        (GC_T, GC_T) => NotBreak,  // GB8
+        (_, GC_Extend) => NotBreak, // GB9
+        (_, GC_ZWJ) => NotBreak,  // GB9
+        (_, GC_SpacingMark) => Extended,  // GB9a
+        (GC_Prepend, _) => Extended,  // GB9b
+        (GC_E_Base, GC_E_Modifier) => NotBreak,  // GB10
+        (GC_E_Base_GAZ, GC_E_Modifier) => NotBreak,  // GB10
+        (GC_Extend, GC_E_Modifier) => Emoji,  // GB10
+        (GC_ZWJ, GC_Glue_After_Zwj) => NotBreak,  // GB11
+        (GC_ZWJ, GC_E_Base_GAZ) => NotBreak,  // GB11
+        (GC_Regional_Indicator, GC_Regional_Indicator) => Regional,  // GB12, GB13
+        (_, _) => Break,  // GB999
+    }
+}
+
+impl GraphemeCursor {
+    /// Create a new cursor. The string and initial offset are given at creation
+    /// time, but the contents of the string are not. The `is_extended` parameter
+    /// controls whether extended grapheme clusters are selected.
+    ///
+    /// The `offset` parameter must be on a codepoint boundary.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::GraphemeCursor;
+    /// let s = "हिन्दी";
+    /// let mut legacy = GraphemeCursor::new(0, s.len(), false);
+    /// assert_eq!(legacy.next_boundary(s, 0), Ok(Some("ह".len())));
+    /// let mut extended = GraphemeCursor::new(0, s.len(), true);
+    /// assert_eq!(extended.next_boundary(s, 0), Ok(Some("हि".len())));
+    /// ```
+    pub fn new(offset: usize, len: usize, is_extended: bool) -> GraphemeCursor {
+        let state = if offset == 0 || offset == len {
+            GraphemeState::Break
+        } else {
+            GraphemeState::Unknown
+        };
+        GraphemeCursor {
+            offset: offset,
+            len: len,
+            state: state,
+            is_extended: is_extended,
+            cat_before: None,
+            cat_after: None,
+            pre_context_offset: None,
+            ris_count: None,
+            resuming: false,
+        }
+    }
+
+    // Not sure I'm gonna keep this, the advantage over new() seems thin.
+
+    /// Set the cursor to a new location in the same string.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::GraphemeCursor;
+    /// let s = "abcd";
+    /// let mut cursor = GraphemeCursor::new(0, s.len(), false);
+    /// assert_eq!(cursor.cur_cursor(), 0);
+    /// cursor.set_cursor(2);
+    /// assert_eq!(cursor.cur_cursor(), 2);
+    /// ```
+    pub fn set_cursor(&mut self, offset: usize) {
+        if offset != self.offset {
+            self.offset = offset;
+            self.state = if offset == 0 || offset == self.len {
+                GraphemeState::Break
+            } else {
+                GraphemeState::Unknown
+            };
+            // reset state derived from text around cursor
+            self.cat_before = None;
+            self.cat_after = None;
+            self.ris_count = None;
+        }
+    }
+
+    /// The current offset of the cursor. Equal to the last value provided to
+    /// `new()` or `set_cursor()`, or returned from `next_boundary()` or
+    /// `prev_boundary()`.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::GraphemeCursor;
+    /// // Two flags (🇷🇸🇮🇴), each flag is two RIS codepoints, each RIS is 4 bytes.
+    /// let flags = "\u{1F1F7}\u{1F1F8}\u{1F1EE}\u{1F1F4}";
+    /// let mut cursor = GraphemeCursor::new(4, flags.len(), false);
+    /// assert_eq!(cursor.cur_cursor(), 4);
+    /// assert_eq!(cursor.next_boundary(flags, 0), Ok(Some(8)));
+    /// assert_eq!(cursor.cur_cursor(), 8);
+    /// ```
+    pub fn cur_cursor(&self) -> usize {
+        self.offset
+    }
+
+    /// Provide additional pre-context when it is needed to decide a boundary.
+    /// The end of the chunk must coincide with the value given in the
+    /// `GraphemeIncomplete::PreContext` request.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
+    /// let flags = "\u{1F1F7}\u{1F1F8}\u{1F1EE}\u{1F1F4}";
+    /// let mut cursor = GraphemeCursor::new(8, flags.len(), false);
+    /// // Not enough pre-context to decide if there's a boundary between the two flags.
+    /// assert_eq!(cursor.is_boundary(&flags[8..], 8), Err(GraphemeIncomplete::PreContext(8)));
+    /// // Provide one more Regional Indicator Symbol of pre-context
+    /// cursor.provide_context(&flags[4..8], 4);
+    /// // Still not enough context to decide.
+    /// assert_eq!(cursor.is_boundary(&flags[8..], 8), Err(GraphemeIncomplete::PreContext(4)));
+    /// // Provide additional requested context.
+    /// cursor.provide_context(&flags[0..4], 0);
+    /// // That's enough to decide (it always is when context goes to the start of the string)
+    /// assert_eq!(cursor.is_boundary(&flags[8..], 8), Ok(true));
+    /// ```
+    pub fn provide_context(&mut self, chunk: &str, chunk_start: usize) {
+        use tables::grapheme as gr;
+        assert!(chunk_start + chunk.len() == self.pre_context_offset.unwrap());
+        self.pre_context_offset = None;
+        if self.is_extended && chunk_start + chunk.len() == self.offset {
+            let ch = chunk.chars().rev().next().unwrap();
+            if gr::grapheme_category(ch) == gr::GC_Prepend {
+                self.decide(false);  // GB9b
+                return;
+            }
+        }
+        match self.state {
+            GraphemeState::Regional => self.handle_regional(chunk, chunk_start),
+            GraphemeState::Emoji => self.handle_emoji(chunk, chunk_start),
+            _ => if self.cat_before.is_none() && self.offset == chunk.len() + chunk_start {
+                let ch = chunk.chars().rev().next().unwrap();
+                self.cat_before = Some(gr::grapheme_category(ch));
+            },
+        }
+    }
+
+    fn decide(&mut self, is_break: bool) {
+        self.state = if is_break {
+            GraphemeState::Break
+        } else {
+            GraphemeState::NotBreak
+        };
+    }
+
+    fn decision(&mut self, is_break: bool) -> Result<bool, GraphemeIncomplete> {
+        self.decide(is_break);
+        Ok(is_break)
+    }
+
+    fn is_boundary_result(&self) -> Result<bool, GraphemeIncomplete> {
+        if self.state == GraphemeState::Break {
+            Ok(true)
+        } else if self.state == GraphemeState::NotBreak {
+            Ok(false)
+        } else if let Some(pre_context_offset) = self.pre_context_offset {
+            Err(GraphemeIncomplete::PreContext(pre_context_offset))
+        } else {
+            unreachable!("inconsistent state");
+        }
+    }
+
+    fn handle_regional(&mut self, chunk: &str, chunk_start: usize) {
+        use tables::grapheme as gr;
+        let mut ris_count = self.ris_count.unwrap_or(0);
+        for ch in chunk.chars().rev() {
+            if gr::grapheme_category(ch) != gr::GC_Regional_Indicator {
+                self.ris_count = Some(ris_count);
+                self.decide((ris_count % 2) == 0);
+                return;
+            }
+            ris_count += 1;
+        }
+        self.ris_count = Some(ris_count);
+        if chunk_start == 0 {
+            self.decide((ris_count % 2) == 0);
+            return;
+        }
+        self.pre_context_offset = Some(chunk_start);
+        self.state = GraphemeState::Regional;
+    }
+
+    fn handle_emoji(&mut self, chunk: &str, chunk_start: usize) {
+        use tables::grapheme as gr;
+        for ch in chunk.chars().rev() {
+            match gr::grapheme_category(ch) {
+                gr::GC_Extend => (),
+                gr::GC_E_Base | gr::GC_E_Base_GAZ => {
+                    self.decide(false);
+                    return;
+                }
+                _ => {
+                    self.decide(true);
+                    return;
+                }
+            }
+        }
+        if chunk_start == 0 {
+            self.decide(true);
+            return;
+        }
+        self.pre_context_offset = Some(chunk_start);
+        self.state = GraphemeState::Emoji;
+    }
+
+    /// Determine whether the current cursor location is a grapheme cluster boundary.
+    /// Only a part of the string need be supplied. If `chunk_start` is nonzero or
+    /// the length of `chunk` is not equal to `len` on creation, then this method
+    /// may return `GraphemeIncomplete::PreContext`. The caller should then
+    /// call `provide_context` with the requested chunk, then retry calling this
+    /// method.
+    ///
+    /// For partial chunks, if the cursor is not at the beginning or end of the
+    /// string, the chunk should contain at least the codepoint following the cursor.
+    /// If the string is nonempty, the chunk must be nonempty.
+    ///
+    /// All calls should have consistent chunk contents (ie, if a chunk provides
+    /// content for a given slice, all further chunks covering that slice must have
+    /// the same content for it).
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::GraphemeCursor;
+    /// let flags = "\u{1F1F7}\u{1F1F8}\u{1F1EE}\u{1F1F4}";
+    /// let mut cursor = GraphemeCursor::new(8, flags.len(), false);
+    /// assert_eq!(cursor.is_boundary(flags, 0), Ok(true));
+    /// cursor.set_cursor(12);
+    /// assert_eq!(cursor.is_boundary(flags, 0), Ok(false));
+    /// ```
+    pub fn is_boundary(&mut self, chunk: &str, chunk_start: usize) -> Result<bool, GraphemeIncomplete> {
+        use tables::grapheme as gr;
+        if self.state == GraphemeState::Break {
+            return Ok(true)
+        }
+        if self.state == GraphemeState::NotBreak {
+            return Ok(false)
+        }
+        if self.offset < chunk_start || self.offset >= chunk_start + chunk.len() {
+            if self.offset > chunk_start + chunk.len() || self.cat_after.is_none() {
+                return Err(GraphemeIncomplete::InvalidOffset)
+            }
+        }
+        if let Some(pre_context_offset) = self.pre_context_offset {
+            return Err(GraphemeIncomplete::PreContext(pre_context_offset));
+        }
+        let offset_in_chunk = self.offset - chunk_start;
+        if self.cat_after.is_none() {
+            let ch = chunk[offset_in_chunk..].chars().next().unwrap();
+            self.cat_after = Some(gr::grapheme_category(ch));
+        }
+        if self.offset == chunk_start {
+            let mut need_pre_context = true;
+            match self.cat_after.unwrap() {
+                gr::GC_Regional_Indicator => self.state = GraphemeState::Regional,
+                gr::GC_E_Modifier => self.state = GraphemeState::Emoji,
+                _ => need_pre_context = self.cat_before.is_none(),
+            }
+            if need_pre_context {
+                self.pre_context_offset = Some(chunk_start);
+                return Err(GraphemeIncomplete::PreContext(chunk_start));
+            }
+        }
+        if self.cat_before.is_none() {
+            let ch = chunk[..offset_in_chunk].chars().rev().next().unwrap();
+            self.cat_before = Some(gr::grapheme_category(ch));
+        }
+        match check_pair(self.cat_before.unwrap(), self.cat_after.unwrap()) {
+            PairResult::NotBreak => return self.decision(false),
+            PairResult::Break => return self.decision(true),
+            PairResult::Extended => {
+                let is_extended = self.is_extended;
+                return self.decision(!is_extended);
+            }
+            PairResult::Regional => {
+                if let Some(ris_count) = self.ris_count {
+                    return self.decision((ris_count % 2) == 0);
+                }
+                self.handle_regional(&chunk[..offset_in_chunk], chunk_start);
+                self.is_boundary_result()
+            }
+            PairResult::Emoji => {
+                self.handle_emoji(&chunk[..offset_in_chunk], chunk_start);
+                self.is_boundary_result()
+            }
+        }
+    }
+
+    /// Find the next boundary after the current cursor position. Only a part of
+    /// the string need be supplied. If the chunk is incomplete, then this
+    /// method might return `GraphemeIncomplete::PreContext` or
+    /// `GraphemeIncomplete::NextChunk`. In the former case, the caller should
+    /// call `provide_context` with the requested chunk, then retry. In the
+    /// latter case, the caller should provide the chunk following the one
+    /// given, then retry.
+    ///
+    /// See `is_boundary` for expectations on the provided chunk.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::GraphemeCursor;
+    /// let flags = "\u{1F1F7}\u{1F1F8}\u{1F1EE}\u{1F1F4}";
+    /// let mut cursor = GraphemeCursor::new(4, flags.len(), false);
+    /// assert_eq!(cursor.next_boundary(flags, 0), Ok(Some(8)));
+    /// assert_eq!(cursor.next_boundary(flags, 0), Ok(Some(16)));
+    /// assert_eq!(cursor.next_boundary(flags, 0), Ok(None));
+    /// ```
+    ///
+    /// And an example that uses partial strings:
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
+    /// let s = "abcd";
+    /// let mut cursor = GraphemeCursor::new(0, s.len(), false);
+    /// assert_eq!(cursor.next_boundary(&s[..2], 0), Ok(Some(1)));
+    /// assert_eq!(cursor.next_boundary(&s[..2], 0), Err(GraphemeIncomplete::NextChunk));
+    /// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(Some(2)));
+    /// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(Some(3)));
+    /// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(Some(4)));
+    /// assert_eq!(cursor.next_boundary(&s[2..4], 2), Ok(None));
+    /// ```
+    pub fn next_boundary(&mut self, chunk: &str, chunk_start: usize) -> Result<Option<usize>, GraphemeIncomplete> {
+        use tables::grapheme as gr;
+        if self.offset == self.len {
+            return Ok(None);
+        }
+        let mut iter = chunk[self.offset - chunk_start..].chars();
+        let mut ch = iter.next().unwrap();
+        loop {
+            if self.resuming {
+                if self.cat_after.is_none() {
+                    self.cat_after = Some(gr::grapheme_category(ch));
+                }
+            } else {
+                self.offset += ch.len_utf8();
+                self.state = GraphemeState::Unknown;
+                self.cat_before = self.cat_after.take();
+                if self.cat_before.is_none() {
+                    self.cat_before = Some(gr::grapheme_category(ch));
+                }
+                if self.cat_before.unwrap() == GraphemeCat::GC_Regional_Indicator {
+                    self.ris_count = self.ris_count.map(|c| c + 1);
+                } else {
+                    self.ris_count = Some(0);
+                }
+                if let Some(next_ch) = iter.next() {
+                    ch = next_ch;
+                    self.cat_after = Some(gr::grapheme_category(ch));
+                } else if self.offset == self.len {
+                    self.decide(true);
+                } else {
+                    self.resuming = true;
+                    return Err(GraphemeIncomplete::NextChunk);
+                }
+            }
+            self.resuming = true;
+            if self.is_boundary(chunk, chunk_start)? {
+                self.resuming = false;
+                return Ok(Some(self.offset));
+            }
+            self.resuming = false;
+        }
+    }
+
+    /// Find the previous boundary after the current cursor position. Only a part
+    /// of the string need be supplied. If the chunk is incomplete, then this
+    /// method might return `GraphemeIncomplete::PreContext` or
+    /// `GraphemeIncomplete::PrevChunk`. In the former case, the caller should
+    /// call `provide_context` with the requested chunk, then retry. In the
+    /// latter case, the caller should provide the chunk preceding the one
+    /// given, then retry.
+    ///
+    /// See `is_boundary` for expectations on the provided chunk.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::GraphemeCursor;
+    /// let flags = "\u{1F1F7}\u{1F1F8}\u{1F1EE}\u{1F1F4}";
+    /// let mut cursor = GraphemeCursor::new(12, flags.len(), false);
+    /// assert_eq!(cursor.prev_boundary(flags, 0), Ok(Some(8)));
+    /// assert_eq!(cursor.prev_boundary(flags, 0), Ok(Some(0)));
+    /// assert_eq!(cursor.prev_boundary(flags, 0), Ok(None));
+    /// ```
+    ///
+    /// And an example that uses partial strings (note the exact return is not
+    /// guaranteed, and may be `PrevChunk` or `PreContext` arbitrarily):
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
+    /// let s = "abcd";
+    /// let mut cursor = GraphemeCursor::new(4, s.len(), false);
+    /// assert_eq!(cursor.prev_boundary(&s[2..4], 2), Ok(Some(3)));
+    /// assert_eq!(cursor.prev_boundary(&s[2..4], 2), Err(GraphemeIncomplete::PrevChunk));
+    /// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(Some(2)));
+    /// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(Some(1)));
+    /// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(Some(0)));
+    /// assert_eq!(cursor.prev_boundary(&s[0..2], 0), Ok(None));
+    /// ```
+    pub fn prev_boundary(&mut self, chunk: &str, chunk_start: usize) -> Result<Option<usize>, GraphemeIncomplete> {
+        use tables::grapheme as gr;
+        if self.offset == 0 {
+            return Ok(None);
+        }
+        if self.offset == chunk_start {
+            return Err(GraphemeIncomplete::PrevChunk);
+        }
+        let mut iter = chunk[..self.offset - chunk_start].chars().rev();
+        let mut ch = iter.next().unwrap();
+        loop {
+            if self.offset == chunk_start {
+                self.resuming = true;
+                return Err(GraphemeIncomplete::PrevChunk);
+            }
+            if self.resuming {
+                self.cat_before = Some(gr::grapheme_category(ch));
+            } else {
+                self.offset -= ch.len_utf8();
+                self.cat_after = self.cat_before.take();
+                self.state = GraphemeState::Unknown;
+                if let Some(ris_count) = self.ris_count {
+                    self.ris_count = if ris_count > 0 { Some(ris_count - 1) } else { None };
+                }
+                if let Some(prev_ch) = iter.next() {
+                    ch = prev_ch;
+                    self.cat_before = Some(gr::grapheme_category(ch));
+                } else if self.offset == 0 {
+                    self.decide(true);
+                } else {
+                    self.resuming = true;
+                    self.cat_after = Some(gr::grapheme_category(ch));
+                    return Err(GraphemeIncomplete::PrevChunk);
+                }
+            }
+            self.resuming = true;
+            if self.is_boundary(chunk, chunk_start)? {
+                self.resuming = false;
+                return Ok(Some(self.offset));
+            }
+            self.resuming = false;
+        }
+    }
+}
+
+#[test]
+fn test_grapheme_cursor_ris_precontext() {
+    let s = "\u{1f1fa}\u{1f1f8}\u{1f1fa}\u{1f1f8}\u{1f1fa}\u{1f1f8}";
+    let mut c = GraphemeCursor::new(8, s.len(), true);
+    assert_eq!(c.is_boundary(&s[4..], 4), Err(GraphemeIncomplete::PreContext(4)));
+    c.provide_context(&s[..4], 0);
+    assert_eq!(c.is_boundary(&s[4..], 4), Ok(true));
+}
+
+#[test]
+fn test_grapheme_cursor_chunk_start_require_precontext() {
+    let s = "\r\n";
+    let mut c = GraphemeCursor::new(1, s.len(), true);
+    assert_eq!(c.is_boundary(&s[1..], 1), Err(GraphemeIncomplete::PreContext(1)));
+    c.provide_context(&s[..1], 0);
+    assert_eq!(c.is_boundary(&s[1..], 1), Ok(false));
+}
+
+#[test]
+fn test_grapheme_cursor_prev_boundary() {
+    let s = "abcd";
+    let mut c = GraphemeCursor::new(3, s.len(), true);
+    assert_eq!(c.prev_boundary(&s[2..], 2), Err(GraphemeIncomplete::PrevChunk));
+    assert_eq!(c.prev_boundary(&s[..2], 0), Ok(Some(2)));
+}
+
+#[test]
+fn test_grapheme_cursor_prev_boundary_chunk_start() {
+    let s = "abcd";
+    let mut c = GraphemeCursor::new(2, s.len(), true);
+    assert_eq!(c.prev_boundary(&s[2..], 2), Err(GraphemeIncomplete::PrevChunk));
+    assert_eq!(c.prev_boundary(&s[..2], 0), Ok(Some(1)));
+}
diff --git a/rustc_deps/vendor/unicode-segmentation/src/lib.rs b/rustc_deps/vendor/unicode-segmentation/src/lib.rs
new file mode 100644
index 0000000..6f903c0
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/src/lib.rs
@@ -0,0 +1,204 @@
+// 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.
+
+//! Iterators which split strings on Grapheme Cluster or Word boundaries, according
+//! to the [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/) rules.
+//!
+//! ```rust
+//! extern crate unicode_segmentation;
+//!
+//! use unicode_segmentation::UnicodeSegmentation;
+//!
+//! fn main() {
+//!     let s = "a̐éö̲\r\n";
+//!     let g = UnicodeSegmentation::graphemes(s, true).collect::<Vec<&str>>();
+//!     let b: &[_] = &["a̐", "é", "ö̲", "\r\n"];
+//!     assert_eq!(g, b);
+//!
+//!     let s = "The quick (\"brown\") fox can't jump 32.3 feet, right?";
+//!     let w = s.unicode_words().collect::<Vec<&str>>();
+//!     let b: &[_] = &["The", "quick", "brown", "fox", "can't", "jump", "32.3", "feet", "right"];
+//!     assert_eq!(w, b);
+//!
+//!     let s = "The quick (\"brown\")  fox";
+//!     let w = s.split_word_bounds().collect::<Vec<&str>>();
+//!     let b: &[_] = &["The", " ", "quick", " ", "(", "\"", "brown", "\"", ")", " ", " ", "fox"];
+//!     assert_eq!(w, b);
+//! }
+//! ```
+//!
+//! # no_std
+//!
+//! unicode-segmentation does not depend on libstd, so it can be used in crates
+//! with the `#![no_std]` attribute.
+//!
+//! # crates.io
+//!
+//! You can use this package in your project by adding the following
+//! to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! unicode-segmentation = "1.1.0"
+//! ```
+
+#![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")]
+
+#![no_std]
+
+#[cfg(test)]
+#[macro_use]
+extern crate std;
+
+#[cfg(test)]
+#[macro_use]
+extern crate quickcheck;
+
+pub use grapheme::{Graphemes, GraphemeIndices};
+pub use grapheme::{GraphemeCursor, GraphemeIncomplete};
+pub use tables::UNICODE_VERSION;
+pub use word::{UWordBounds, UWordBoundIndices, UnicodeWords};
+
+mod grapheme;
+mod tables;
+mod word;
+
+#[cfg(test)]
+mod test;
+#[cfg(test)]
+mod testdata;
+
+/// Methods for segmenting strings according to
+/// [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/).
+pub trait UnicodeSegmentation {
+    /// Returns an iterator over the [grapheme clusters][graphemes] of `self`.
+    ///
+    /// [graphemes]: http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries
+    ///
+    /// If `is_extended` is true, the iterator is over the
+    /// *extended grapheme clusters*;
+    /// otherwise, the iterator is over the *legacy grapheme clusters*.
+    /// [UAX#29](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries)
+    /// recommends extended grapheme cluster boundaries for general processing.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use self::unicode_segmentation::UnicodeSegmentation;
+    /// let gr1 = UnicodeSegmentation::graphemes("a\u{310}e\u{301}o\u{308}\u{332}", true)
+    ///           .collect::<Vec<&str>>();
+    /// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];
+    ///
+    /// assert_eq!(&gr1[..], b);
+    ///
+    /// let gr2 = UnicodeSegmentation::graphemes("a\r\nb🇷🇺🇸🇹", true).collect::<Vec<&str>>();
+    /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺", "🇸🇹"];
+    ///
+    /// assert_eq!(&gr2[..], b);
+    /// ```
+    fn graphemes<'a>(&'a self, is_extended: bool) -> Graphemes<'a>;
+
+    /// Returns an iterator over the grapheme clusters of `self` and their
+    /// byte offsets. See `graphemes()` for more information.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use self::unicode_segmentation::UnicodeSegmentation;
+    /// let gr_inds = UnicodeSegmentation::grapheme_indices("a̐éö̲\r\n", true)
+    ///               .collect::<Vec<(usize, &str)>>();
+    /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+    ///
+    /// assert_eq!(&gr_inds[..], b);
+    /// ```
+    fn grapheme_indices<'a>(&'a self, is_extended: bool) -> GraphemeIndices<'a>;
+
+    /// Returns an iterator over the words of `self`, separated on
+    /// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries).
+    ///
+    /// Here, "words" are just those substrings which, after splitting on
+    /// UAX#29 word boundaries, contain any alphanumeric characters. That is, the
+    /// substring must contain at least one character with the
+    /// [Alphabetic](http://unicode.org/reports/tr44/#Alphabetic)
+    /// property, or with
+    /// [General_Category=Number](http://unicode.org/reports/tr44/#General_Category_Values).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use self::unicode_segmentation::UnicodeSegmentation;
+    /// let uws = "The quick (\"brown\") fox can't jump 32.3 feet, right?";
+    /// let uw1 = uws.unicode_words().collect::<Vec<&str>>();
+    /// let b: &[_] = &["The", "quick", "brown", "fox", "can't", "jump", "32.3", "feet", "right"];
+    ///
+    /// assert_eq!(&uw1[..], b);
+    /// ```
+    fn unicode_words<'a>(&'a self) -> UnicodeWords<'a>;
+
+    /// Returns an iterator over substrings of `self` separated on
+    /// [UAX#29 word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries).
+    ///
+    /// The concatenation of the substrings returned by this function is just the original string.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use self::unicode_segmentation::UnicodeSegmentation;
+    /// let swu1 = "The quick (\"brown\")  fox".split_word_bounds().collect::<Vec<&str>>();
+    /// let b: &[_] = &["The", " ", "quick", " ", "(", "\"", "brown", "\"", ")", " ", " ", "fox"];
+    ///
+    /// assert_eq!(&swu1[..], b);
+    /// ```
+    fn split_word_bounds<'a>(&'a self) -> UWordBounds<'a>;
+
+    /// Returns an iterator over substrings of `self`, split on UAX#29 word boundaries,
+    /// and their offsets. See `split_word_bounds()` for more information.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use self::unicode_segmentation::UnicodeSegmentation;
+    /// let swi1 = "Brr, it's 29.3°F!".split_word_bound_indices().collect::<Vec<(usize, &str)>>();
+    /// let b: &[_] = &[(0, "Brr"), (3, ","), (4, " "), (5, "it's"), (9, " "), (10, "29.3"),
+    ///                 (14, "°"), (16, "F"), (17, "!")];
+    ///
+    /// assert_eq!(&swi1[..], b);
+    /// ```
+    fn split_word_bound_indices<'a>(&'a self) -> UWordBoundIndices<'a>;
+}
+
+impl UnicodeSegmentation for str {
+    #[inline]
+    fn graphemes(&self, is_extended: bool) -> Graphemes {
+        grapheme::new_graphemes(self, is_extended)
+    }
+
+    #[inline]
+    fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
+        grapheme::new_grapheme_indices(self, is_extended)
+    }
+
+    #[inline]
+    fn unicode_words(&self) -> UnicodeWords {
+        word::new_unicode_words(self)
+    }
+
+    #[inline]
+    fn split_word_bounds(&self) -> UWordBounds {
+        word::new_word_bounds(self)
+    }
+
+    #[inline]
+    fn split_word_bound_indices(&self) -> UWordBoundIndices {
+        word::new_word_bound_indices(self)
+    }
+}
diff --git a/rustc_deps/vendor/unicode-segmentation/src/tables.rs b/rustc_deps/vendor/unicode-segmentation/src/tables.rs
new file mode 100644
index 0000000..625a588
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/src/tables.rs
@@ -0,0 +1,1325 @@
+// 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.
+
+// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
+
+#![allow(missing_docs, non_upper_case_globals, non_snake_case)]
+
+/// The version of [Unicode](http://www.unicode.org/)
+/// that this version of unicode-segmentation is based on.
+pub const UNICODE_VERSION: (u64, u64, u64) = (9, 0, 0);
+
+pub mod util {
+    #[inline]
+    pub fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        r.binary_search_by(|&(lo,hi)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }).is_ok()
+    }
+
+    #[inline]
+    fn is_alphabetic(c: char) -> bool {
+        match c {
+            'a' ... 'z' | 'A' ... 'Z' => true,
+            c if c > '' => super::derived_property::Alphabetic(c),
+            _ => false,
+        }
+    }
+
+    #[inline]
+    fn is_numeric(c: char) -> bool {
+        match c {
+            '0' ... '9' => true,
+            c if c > '' => super::general_category::N(c),
+            _ => false,
+        }
+    }
+
+    #[inline]
+    pub fn is_alphanumeric(c: char) -> bool {
+        is_alphabetic(c) || is_numeric(c)
+    }
+}
+
+mod general_category {
+    const N_table: &'static [(char, char)] = &[
+        ('\u{30}', '\u{39}'), ('\u{660}', '\u{669}'), ('\u{6f0}', '\u{6f9}'), ('\u{7c0}',
+        '\u{7c9}'), ('\u{966}', '\u{96f}'), ('\u{9e6}', '\u{9ef}'), ('\u{a66}', '\u{a6f}'),
+        ('\u{ae6}', '\u{aef}'), ('\u{b66}', '\u{b6f}'), ('\u{be6}', '\u{bef}'), ('\u{c66}',
+        '\u{c6f}'), ('\u{ce6}', '\u{cef}'), ('\u{d66}', '\u{d6f}'), ('\u{de6}', '\u{def}'),
+        ('\u{e50}', '\u{e59}'), ('\u{ed0}', '\u{ed9}'), ('\u{f20}', '\u{f29}'), ('\u{1040}',
+        '\u{1049}'), ('\u{1090}', '\u{1099}'), ('\u{16ee}', '\u{16f0}'), ('\u{17e0}', '\u{17e9}'),
+        ('\u{1810}', '\u{1819}'), ('\u{1946}', '\u{194f}'), ('\u{19d0}', '\u{19d9}'), ('\u{1a80}',
+        '\u{1a89}'), ('\u{1a90}', '\u{1a99}'), ('\u{1b50}', '\u{1b59}'), ('\u{1bb0}', '\u{1bb9}'),
+        ('\u{1c40}', '\u{1c49}'), ('\u{1c50}', '\u{1c59}'), ('\u{2160}', '\u{2182}'), ('\u{2185}',
+        '\u{2188}'), ('\u{3007}', '\u{3007}'), ('\u{3021}', '\u{3029}'), ('\u{3038}', '\u{303a}'),
+        ('\u{a620}', '\u{a629}'), ('\u{a6e6}', '\u{a6ef}'), ('\u{a8d0}', '\u{a8d9}'), ('\u{a900}',
+        '\u{a909}'), ('\u{a9d0}', '\u{a9d9}'), ('\u{a9f0}', '\u{a9f9}'), ('\u{aa50}', '\u{aa59}'),
+        ('\u{abf0}', '\u{abf9}'), ('\u{ff10}', '\u{ff19}'), ('\u{10140}', '\u{10174}'),
+        ('\u{10341}', '\u{10341}'), ('\u{1034a}', '\u{1034a}'), ('\u{103d1}', '\u{103d5}'),
+        ('\u{104a0}', '\u{104a9}'), ('\u{11066}', '\u{1106f}'), ('\u{110f0}', '\u{110f9}'),
+        ('\u{11136}', '\u{1113f}'), ('\u{111d0}', '\u{111d9}'), ('\u{112f0}', '\u{112f9}'),
+        ('\u{11450}', '\u{11459}'), ('\u{114d0}', '\u{114d9}'), ('\u{11650}', '\u{11659}'),
+        ('\u{116c0}', '\u{116c9}'), ('\u{11730}', '\u{11739}'), ('\u{118e0}', '\u{118e9}'),
+        ('\u{11c50}', '\u{11c59}'), ('\u{12400}', '\u{1246e}'), ('\u{16a60}', '\u{16a69}'),
+        ('\u{16b50}', '\u{16b59}'), ('\u{1d7ce}', '\u{1d7ff}'), ('\u{1e950}', '\u{1e959}')
+    ];
+
+    #[inline]
+    pub fn N(c: char) -> bool {
+        super::util::bsearch_range_table(c, N_table)
+    }
+
+}
+
+mod derived_property {
+    const Alphabetic_table: &'static [(char, char)] = &[
+        ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'),
+        ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{2c1}'),
+        ('\u{2c6}', '\u{2d1}'), ('\u{2e0}', '\u{2e4}'), ('\u{2ec}', '\u{2ec}'), ('\u{2ee}',
+        '\u{2ee}'), ('\u{345}', '\u{345}'), ('\u{370}', '\u{374}'), ('\u{376}', '\u{377}'),
+        ('\u{37a}', '\u{37d}'), ('\u{37f}', '\u{37f}'), ('\u{386}', '\u{386}'), ('\u{388}',
+        '\u{38a}'), ('\u{38c}', '\u{38c}'), ('\u{38e}', '\u{3a1}'), ('\u{3a3}', '\u{3f5}'),
+        ('\u{3f7}', '\u{481}'), ('\u{48a}', '\u{52f}'), ('\u{531}', '\u{556}'), ('\u{559}',
+        '\u{559}'), ('\u{561}', '\u{587}'), ('\u{5b0}', '\u{5bd}'), ('\u{5bf}', '\u{5bf}'),
+        ('\u{5c1}', '\u{5c2}'), ('\u{5c4}', '\u{5c5}'), ('\u{5c7}', '\u{5c7}'), ('\u{5d0}',
+        '\u{5ea}'), ('\u{5f0}', '\u{5f2}'), ('\u{610}', '\u{61a}'), ('\u{620}', '\u{657}'),
+        ('\u{659}', '\u{65f}'), ('\u{66e}', '\u{6d3}'), ('\u{6d5}', '\u{6dc}'), ('\u{6e1}',
+        '\u{6e8}'), ('\u{6ed}', '\u{6ef}'), ('\u{6fa}', '\u{6fc}'), ('\u{6ff}', '\u{6ff}'),
+        ('\u{710}', '\u{73f}'), ('\u{74d}', '\u{7b1}'), ('\u{7ca}', '\u{7ea}'), ('\u{7f4}',
+        '\u{7f5}'), ('\u{7fa}', '\u{7fa}'), ('\u{800}', '\u{817}'), ('\u{81a}', '\u{82c}'),
+        ('\u{840}', '\u{858}'), ('\u{8a0}', '\u{8b4}'), ('\u{8b6}', '\u{8bd}'), ('\u{8d4}',
+        '\u{8df}'), ('\u{8e3}', '\u{8e9}'), ('\u{8f0}', '\u{93b}'), ('\u{93d}', '\u{94c}'),
+        ('\u{94e}', '\u{950}'), ('\u{955}', '\u{963}'), ('\u{971}', '\u{983}'), ('\u{985}',
+        '\u{98c}'), ('\u{98f}', '\u{990}'), ('\u{993}', '\u{9a8}'), ('\u{9aa}', '\u{9b0}'),
+        ('\u{9b2}', '\u{9b2}'), ('\u{9b6}', '\u{9b9}'), ('\u{9bd}', '\u{9c4}'), ('\u{9c7}',
+        '\u{9c8}'), ('\u{9cb}', '\u{9cc}'), ('\u{9ce}', '\u{9ce}'), ('\u{9d7}', '\u{9d7}'),
+        ('\u{9dc}', '\u{9dd}'), ('\u{9df}', '\u{9e3}'), ('\u{9f0}', '\u{9f1}'), ('\u{a01}',
+        '\u{a03}'), ('\u{a05}', '\u{a0a}'), ('\u{a0f}', '\u{a10}'), ('\u{a13}', '\u{a28}'),
+        ('\u{a2a}', '\u{a30}'), ('\u{a32}', '\u{a33}'), ('\u{a35}', '\u{a36}'), ('\u{a38}',
+        '\u{a39}'), ('\u{a3e}', '\u{a42}'), ('\u{a47}', '\u{a48}'), ('\u{a4b}', '\u{a4c}'),
+        ('\u{a51}', '\u{a51}'), ('\u{a59}', '\u{a5c}'), ('\u{a5e}', '\u{a5e}'), ('\u{a70}',
+        '\u{a75}'), ('\u{a81}', '\u{a83}'), ('\u{a85}', '\u{a8d}'), ('\u{a8f}', '\u{a91}'),
+        ('\u{a93}', '\u{aa8}'), ('\u{aaa}', '\u{ab0}'), ('\u{ab2}', '\u{ab3}'), ('\u{ab5}',
+        '\u{ab9}'), ('\u{abd}', '\u{ac5}'), ('\u{ac7}', '\u{ac9}'), ('\u{acb}', '\u{acc}'),
+        ('\u{ad0}', '\u{ad0}'), ('\u{ae0}', '\u{ae3}'), ('\u{af9}', '\u{af9}'), ('\u{b01}',
+        '\u{b03}'), ('\u{b05}', '\u{b0c}'), ('\u{b0f}', '\u{b10}'), ('\u{b13}', '\u{b28}'),
+        ('\u{b2a}', '\u{b30}'), ('\u{b32}', '\u{b33}'), ('\u{b35}', '\u{b39}'), ('\u{b3d}',
+        '\u{b44}'), ('\u{b47}', '\u{b48}'), ('\u{b4b}', '\u{b4c}'), ('\u{b56}', '\u{b57}'),
+        ('\u{b5c}', '\u{b5d}'), ('\u{b5f}', '\u{b63}'), ('\u{b71}', '\u{b71}'), ('\u{b82}',
+        '\u{b83}'), ('\u{b85}', '\u{b8a}'), ('\u{b8e}', '\u{b90}'), ('\u{b92}', '\u{b95}'),
+        ('\u{b99}', '\u{b9a}'), ('\u{b9c}', '\u{b9c}'), ('\u{b9e}', '\u{b9f}'), ('\u{ba3}',
+        '\u{ba4}'), ('\u{ba8}', '\u{baa}'), ('\u{bae}', '\u{bb9}'), ('\u{bbe}', '\u{bc2}'),
+        ('\u{bc6}', '\u{bc8}'), ('\u{bca}', '\u{bcc}'), ('\u{bd0}', '\u{bd0}'), ('\u{bd7}',
+        '\u{bd7}'), ('\u{c00}', '\u{c03}'), ('\u{c05}', '\u{c0c}'), ('\u{c0e}', '\u{c10}'),
+        ('\u{c12}', '\u{c28}'), ('\u{c2a}', '\u{c39}'), ('\u{c3d}', '\u{c44}'), ('\u{c46}',
+        '\u{c48}'), ('\u{c4a}', '\u{c4c}'), ('\u{c55}', '\u{c56}'), ('\u{c58}', '\u{c5a}'),
+        ('\u{c60}', '\u{c63}'), ('\u{c80}', '\u{c83}'), ('\u{c85}', '\u{c8c}'), ('\u{c8e}',
+        '\u{c90}'), ('\u{c92}', '\u{ca8}'), ('\u{caa}', '\u{cb3}'), ('\u{cb5}', '\u{cb9}'),
+        ('\u{cbd}', '\u{cc4}'), ('\u{cc6}', '\u{cc8}'), ('\u{cca}', '\u{ccc}'), ('\u{cd5}',
+        '\u{cd6}'), ('\u{cde}', '\u{cde}'), ('\u{ce0}', '\u{ce3}'), ('\u{cf1}', '\u{cf2}'),
+        ('\u{d01}', '\u{d03}'), ('\u{d05}', '\u{d0c}'), ('\u{d0e}', '\u{d10}'), ('\u{d12}',
+        '\u{d3a}'), ('\u{d3d}', '\u{d44}'), ('\u{d46}', '\u{d48}'), ('\u{d4a}', '\u{d4c}'),
+        ('\u{d4e}', '\u{d4e}'), ('\u{d54}', '\u{d57}'), ('\u{d5f}', '\u{d63}'), ('\u{d7a}',
+        '\u{d7f}'), ('\u{d82}', '\u{d83}'), ('\u{d85}', '\u{d96}'), ('\u{d9a}', '\u{db1}'),
+        ('\u{db3}', '\u{dbb}'), ('\u{dbd}', '\u{dbd}'), ('\u{dc0}', '\u{dc6}'), ('\u{dcf}',
+        '\u{dd4}'), ('\u{dd6}', '\u{dd6}'), ('\u{dd8}', '\u{ddf}'), ('\u{df2}', '\u{df3}'),
+        ('\u{e01}', '\u{e3a}'), ('\u{e40}', '\u{e46}'), ('\u{e4d}', '\u{e4d}'), ('\u{e81}',
+        '\u{e82}'), ('\u{e84}', '\u{e84}'), ('\u{e87}', '\u{e88}'), ('\u{e8a}', '\u{e8a}'),
+        ('\u{e8d}', '\u{e8d}'), ('\u{e94}', '\u{e97}'), ('\u{e99}', '\u{e9f}'), ('\u{ea1}',
+        '\u{ea3}'), ('\u{ea5}', '\u{ea5}'), ('\u{ea7}', '\u{ea7}'), ('\u{eaa}', '\u{eab}'),
+        ('\u{ead}', '\u{eb9}'), ('\u{ebb}', '\u{ebd}'), ('\u{ec0}', '\u{ec4}'), ('\u{ec6}',
+        '\u{ec6}'), ('\u{ecd}', '\u{ecd}'), ('\u{edc}', '\u{edf}'), ('\u{f00}', '\u{f00}'),
+        ('\u{f40}', '\u{f47}'), ('\u{f49}', '\u{f6c}'), ('\u{f71}', '\u{f81}'), ('\u{f88}',
+        '\u{f97}'), ('\u{f99}', '\u{fbc}'), ('\u{1000}', '\u{1036}'), ('\u{1038}', '\u{1038}'),
+        ('\u{103b}', '\u{103f}'), ('\u{1050}', '\u{1062}'), ('\u{1065}', '\u{1068}'), ('\u{106e}',
+        '\u{1086}'), ('\u{108e}', '\u{108e}'), ('\u{109c}', '\u{109d}'), ('\u{10a0}', '\u{10c5}'),
+        ('\u{10c7}', '\u{10c7}'), ('\u{10cd}', '\u{10cd}'), ('\u{10d0}', '\u{10fa}'), ('\u{10fc}',
+        '\u{1248}'), ('\u{124a}', '\u{124d}'), ('\u{1250}', '\u{1256}'), ('\u{1258}', '\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{12c0}'),
+        ('\u{12c2}', '\u{12c5}'), ('\u{12c8}', '\u{12d6}'), ('\u{12d8}', '\u{1310}'), ('\u{1312}',
+        '\u{1315}'), ('\u{1318}', '\u{135a}'), ('\u{135f}', '\u{135f}'), ('\u{1380}', '\u{138f}'),
+        ('\u{13a0}', '\u{13f5}'), ('\u{13f8}', '\u{13fd}'), ('\u{1401}', '\u{166c}'), ('\u{166f}',
+        '\u{167f}'), ('\u{1681}', '\u{169a}'), ('\u{16a0}', '\u{16ea}'), ('\u{16ee}', '\u{16f8}'),
+        ('\u{1700}', '\u{170c}'), ('\u{170e}', '\u{1713}'), ('\u{1720}', '\u{1733}'), ('\u{1740}',
+        '\u{1753}'), ('\u{1760}', '\u{176c}'), ('\u{176e}', '\u{1770}'), ('\u{1772}', '\u{1773}'),
+        ('\u{1780}', '\u{17b3}'), ('\u{17b6}', '\u{17c8}'), ('\u{17d7}', '\u{17d7}'), ('\u{17dc}',
+        '\u{17dc}'), ('\u{1820}', '\u{1877}'), ('\u{1880}', '\u{18aa}'), ('\u{18b0}', '\u{18f5}'),
+        ('\u{1900}', '\u{191e}'), ('\u{1920}', '\u{192b}'), ('\u{1930}', '\u{1938}'), ('\u{1950}',
+        '\u{196d}'), ('\u{1970}', '\u{1974}'), ('\u{1980}', '\u{19ab}'), ('\u{19b0}', '\u{19c9}'),
+        ('\u{1a00}', '\u{1a1b}'), ('\u{1a20}', '\u{1a5e}'), ('\u{1a61}', '\u{1a74}'), ('\u{1aa7}',
+        '\u{1aa7}'), ('\u{1b00}', '\u{1b33}'), ('\u{1b35}', '\u{1b43}'), ('\u{1b45}', '\u{1b4b}'),
+        ('\u{1b80}', '\u{1ba9}'), ('\u{1bac}', '\u{1baf}'), ('\u{1bba}', '\u{1be5}'), ('\u{1be7}',
+        '\u{1bf1}'), ('\u{1c00}', '\u{1c35}'), ('\u{1c4d}', '\u{1c4f}'), ('\u{1c5a}', '\u{1c7d}'),
+        ('\u{1c80}', '\u{1c88}'), ('\u{1ce9}', '\u{1cec}'), ('\u{1cee}', '\u{1cf3}'), ('\u{1cf5}',
+        '\u{1cf6}'), ('\u{1d00}', '\u{1dbf}'), ('\u{1de7}', '\u{1df4}'), ('\u{1e00}', '\u{1f15}'),
+        ('\u{1f18}', '\u{1f1d}'), ('\u{1f20}', '\u{1f45}'), ('\u{1f48}', '\u{1f4d}'), ('\u{1f50}',
+        '\u{1f57}'), ('\u{1f59}', '\u{1f59}'), ('\u{1f5b}', '\u{1f5b}'), ('\u{1f5d}', '\u{1f5d}'),
+        ('\u{1f5f}', '\u{1f7d}'), ('\u{1f80}', '\u{1fb4}'), ('\u{1fb6}', '\u{1fbc}'), ('\u{1fbe}',
+        '\u{1fbe}'), ('\u{1fc2}', '\u{1fc4}'), ('\u{1fc6}', '\u{1fcc}'), ('\u{1fd0}', '\u{1fd3}'),
+        ('\u{1fd6}', '\u{1fdb}'), ('\u{1fe0}', '\u{1fec}'), ('\u{1ff2}', '\u{1ff4}'), ('\u{1ff6}',
+        '\u{1ffc}'), ('\u{2071}', '\u{2071}'), ('\u{207f}', '\u{207f}'), ('\u{2090}', '\u{209c}'),
+        ('\u{2102}', '\u{2102}'), ('\u{2107}', '\u{2107}'), ('\u{210a}', '\u{2113}'), ('\u{2115}',
+        '\u{2115}'), ('\u{2119}', '\u{211d}'), ('\u{2124}', '\u{2124}'), ('\u{2126}', '\u{2126}'),
+        ('\u{2128}', '\u{2128}'), ('\u{212a}', '\u{212d}'), ('\u{212f}', '\u{2139}'), ('\u{213c}',
+        '\u{213f}'), ('\u{2145}', '\u{2149}'), ('\u{214e}', '\u{214e}'), ('\u{2160}', '\u{2188}'),
+        ('\u{24b6}', '\u{24e9}'), ('\u{2c00}', '\u{2c2e}'), ('\u{2c30}', '\u{2c5e}'), ('\u{2c60}',
+        '\u{2ce4}'), ('\u{2ceb}', '\u{2cee}'), ('\u{2cf2}', '\u{2cf3}'), ('\u{2d00}', '\u{2d25}'),
+        ('\u{2d27}', '\u{2d27}'), ('\u{2d2d}', '\u{2d2d}'), ('\u{2d30}', '\u{2d67}'), ('\u{2d6f}',
+        '\u{2d6f}'), ('\u{2d80}', '\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{2dff}'),
+        ('\u{2e2f}', '\u{2e2f}'), ('\u{3005}', '\u{3007}'), ('\u{3021}', '\u{3029}'), ('\u{3031}',
+        '\u{3035}'), ('\u{3038}', '\u{303c}'), ('\u{3041}', '\u{3096}'), ('\u{309d}', '\u{309f}'),
+        ('\u{30a1}', '\u{30fa}'), ('\u{30fc}', '\u{30ff}'), ('\u{3105}', '\u{312d}'), ('\u{3131}',
+        '\u{318e}'), ('\u{31a0}', '\u{31ba}'), ('\u{31f0}', '\u{31ff}'), ('\u{3400}', '\u{4db5}'),
+        ('\u{4e00}', '\u{9fd5}'), ('\u{a000}', '\u{a48c}'), ('\u{a4d0}', '\u{a4fd}'), ('\u{a500}',
+        '\u{a60c}'), ('\u{a610}', '\u{a61f}'), ('\u{a62a}', '\u{a62b}'), ('\u{a640}', '\u{a66e}'),
+        ('\u{a674}', '\u{a67b}'), ('\u{a67f}', '\u{a6ef}'), ('\u{a717}', '\u{a71f}'), ('\u{a722}',
+        '\u{a788}'), ('\u{a78b}', '\u{a7ae}'), ('\u{a7b0}', '\u{a7b7}'), ('\u{a7f7}', '\u{a801}'),
+        ('\u{a803}', '\u{a805}'), ('\u{a807}', '\u{a80a}'), ('\u{a80c}', '\u{a827}'), ('\u{a840}',
+        '\u{a873}'), ('\u{a880}', '\u{a8c3}'), ('\u{a8c5}', '\u{a8c5}'), ('\u{a8f2}', '\u{a8f7}'),
+        ('\u{a8fb}', '\u{a8fb}'), ('\u{a8fd}', '\u{a8fd}'), ('\u{a90a}', '\u{a92a}'), ('\u{a930}',
+        '\u{a952}'), ('\u{a960}', '\u{a97c}'), ('\u{a980}', '\u{a9b2}'), ('\u{a9b4}', '\u{a9bf}'),
+        ('\u{a9cf}', '\u{a9cf}'), ('\u{a9e0}', '\u{a9e4}'), ('\u{a9e6}', '\u{a9ef}'), ('\u{a9fa}',
+        '\u{a9fe}'), ('\u{aa00}', '\u{aa36}'), ('\u{aa40}', '\u{aa4d}'), ('\u{aa60}', '\u{aa76}'),
+        ('\u{aa7a}', '\u{aa7a}'), ('\u{aa7e}', '\u{aabe}'), ('\u{aac0}', '\u{aac0}'), ('\u{aac2}',
+        '\u{aac2}'), ('\u{aadb}', '\u{aadd}'), ('\u{aae0}', '\u{aaef}'), ('\u{aaf2}', '\u{aaf5}'),
+        ('\u{ab01}', '\u{ab06}'), ('\u{ab09}', '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}',
+        '\u{ab26}'), ('\u{ab28}', '\u{ab2e}'), ('\u{ab30}', '\u{ab5a}'), ('\u{ab5c}', '\u{ab65}'),
+        ('\u{ab70}', '\u{abea}'), ('\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{fb28}'), ('\u{fb2a}', '\u{fb36}'), ('\u{fb38}',
+        '\u{fb3c}'), ('\u{fb3e}', '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}', '\u{fb44}'),
+        ('\u{fb46}', '\u{fbb1}'), ('\u{fbd3}', '\u{fd3d}'), ('\u{fd50}', '\u{fd8f}'), ('\u{fd92}',
+        '\u{fdc7}'), ('\u{fdf0}', '\u{fdfb}'), ('\u{fe70}', '\u{fe74}'), ('\u{fe76}', '\u{fefc}'),
+        ('\u{ff21}', '\u{ff3a}'), ('\u{ff41}', '\u{ff5a}'), ('\u{ff66}', '\u{ffbe}'), ('\u{ffc2}',
+        '\u{ffc7}'), ('\u{ffca}', '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}'),
+        ('\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{10140}', '\u{10174}'), ('\u{10280}', '\u{1029c}'),
+        ('\u{102a0}', '\u{102d0}'), ('\u{10300}', '\u{1031f}'), ('\u{10330}', '\u{1034a}'),
+        ('\u{10350}', '\u{1037a}'), ('\u{10380}', '\u{1039d}'), ('\u{103a0}', '\u{103c3}'),
+        ('\u{103c8}', '\u{103cf}'), ('\u{103d1}', '\u{103d5}'), ('\u{10400}', '\u{1049d}'),
+        ('\u{104b0}', '\u{104d3}'), ('\u{104d8}', '\u{104fb}'), ('\u{10500}', '\u{10527}'),
+        ('\u{10530}', '\u{10563}'), ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'),
+        ('\u{10760}', '\u{10767}'), ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'),
+        ('\u{1080a}', '\u{10835}'), ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'),
+        ('\u{1083f}', '\u{10855}'), ('\u{10860}', '\u{10876}'), ('\u{10880}', '\u{1089e}'),
+        ('\u{108e0}', '\u{108f2}'), ('\u{108f4}', '\u{108f5}'), ('\u{10900}', '\u{10915}'),
+        ('\u{10920}', '\u{10939}'), ('\u{10980}', '\u{109b7}'), ('\u{109be}', '\u{109bf}'),
+        ('\u{10a00}', '\u{10a03}'), ('\u{10a05}', '\u{10a06}'), ('\u{10a0c}', '\u{10a13}'),
+        ('\u{10a15}', '\u{10a17}'), ('\u{10a19}', '\u{10a33}'), ('\u{10a60}', '\u{10a7c}'),
+        ('\u{10a80}', '\u{10a9c}'), ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac9}', '\u{10ae4}'),
+        ('\u{10b00}', '\u{10b35}'), ('\u{10b40}', '\u{10b55}'), ('\u{10b60}', '\u{10b72}'),
+        ('\u{10b80}', '\u{10b91}'), ('\u{10c00}', '\u{10c48}'), ('\u{10c80}', '\u{10cb2}'),
+        ('\u{10cc0}', '\u{10cf2}'), ('\u{11000}', '\u{11045}'), ('\u{11082}', '\u{110b8}'),
+        ('\u{110d0}', '\u{110e8}'), ('\u{11100}', '\u{11132}'), ('\u{11150}', '\u{11172}'),
+        ('\u{11176}', '\u{11176}'), ('\u{11180}', '\u{111bf}'), ('\u{111c1}', '\u{111c4}'),
+        ('\u{111da}', '\u{111da}'), ('\u{111dc}', '\u{111dc}'), ('\u{11200}', '\u{11211}'),
+        ('\u{11213}', '\u{11234}'), ('\u{11237}', '\u{11237}'), ('\u{1123e}', '\u{1123e}'),
+        ('\u{11280}', '\u{11286}'), ('\u{11288}', '\u{11288}'), ('\u{1128a}', '\u{1128d}'),
+        ('\u{1128f}', '\u{1129d}'), ('\u{1129f}', '\u{112a8}'), ('\u{112b0}', '\u{112e8}'),
+        ('\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{1133d}', '\u{11344}'), ('\u{11347}', '\u{11348}'),
+        ('\u{1134b}', '\u{1134c}'), ('\u{11350}', '\u{11350}'), ('\u{11357}', '\u{11357}'),
+        ('\u{1135d}', '\u{11363}'), ('\u{11400}', '\u{11441}'), ('\u{11443}', '\u{11445}'),
+        ('\u{11447}', '\u{1144a}'), ('\u{11480}', '\u{114c1}'), ('\u{114c4}', '\u{114c5}'),
+        ('\u{114c7}', '\u{114c7}'), ('\u{11580}', '\u{115b5}'), ('\u{115b8}', '\u{115be}'),
+        ('\u{115d8}', '\u{115dd}'), ('\u{11600}', '\u{1163e}'), ('\u{11640}', '\u{11640}'),
+        ('\u{11644}', '\u{11644}'), ('\u{11680}', '\u{116b5}'), ('\u{11700}', '\u{11719}'),
+        ('\u{1171d}', '\u{1172a}'), ('\u{118a0}', '\u{118df}'), ('\u{118ff}', '\u{118ff}'),
+        ('\u{11ac0}', '\u{11af8}'), ('\u{11c00}', '\u{11c08}'), ('\u{11c0a}', '\u{11c36}'),
+        ('\u{11c38}', '\u{11c3e}'), ('\u{11c40}', '\u{11c40}'), ('\u{11c72}', '\u{11c8f}'),
+        ('\u{11c92}', '\u{11ca7}'), ('\u{11ca9}', '\u{11cb6}'), ('\u{12000}', '\u{12399}'),
+        ('\u{12400}', '\u{1246e}'), ('\u{12480}', '\u{12543}'), ('\u{13000}', '\u{1342e}'),
+        ('\u{14400}', '\u{14646}'), ('\u{16800}', '\u{16a38}'), ('\u{16a40}', '\u{16a5e}'),
+        ('\u{16ad0}', '\u{16aed}'), ('\u{16b00}', '\u{16b36}'), ('\u{16b40}', '\u{16b43}'),
+        ('\u{16b63}', '\u{16b77}'), ('\u{16b7d}', '\u{16b8f}'), ('\u{16f00}', '\u{16f44}'),
+        ('\u{16f50}', '\u{16f7e}'), ('\u{16f93}', '\u{16f9f}'), ('\u{16fe0}', '\u{16fe0}'),
+        ('\u{17000}', '\u{187ec}'), ('\u{18800}', '\u{18af2}'), ('\u{1b000}', '\u{1b001}'),
+        ('\u{1bc00}', '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'), ('\u{1bc80}', '\u{1bc88}'),
+        ('\u{1bc90}', '\u{1bc99}'), ('\u{1bc9e}', '\u{1bc9e}'), ('\u{1d400}', '\u{1d454}'),
+        ('\u{1d456}', '\u{1d49c}'), ('\u{1d49e}', '\u{1d49f}'), ('\u{1d4a2}', '\u{1d4a2}'),
+        ('\u{1d4a5}', '\u{1d4a6}'), ('\u{1d4a9}', '\u{1d4ac}'), ('\u{1d4ae}', '\u{1d4b9}'),
+        ('\u{1d4bb}', '\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{1d546}'), ('\u{1d54a}', '\u{1d550}'), ('\u{1d552}', '\u{1d6a5}'),
+        ('\u{1d6a8}', '\u{1d6c0}'), ('\u{1d6c2}', '\u{1d6da}'), ('\u{1d6dc}', '\u{1d6fa}'),
+        ('\u{1d6fc}', '\u{1d714}'), ('\u{1d716}', '\u{1d734}'), ('\u{1d736}', '\u{1d74e}'),
+        ('\u{1d750}', '\u{1d76e}'), ('\u{1d770}', '\u{1d788}'), ('\u{1d78a}', '\u{1d7a8}'),
+        ('\u{1d7aa}', '\u{1d7c2}'), ('\u{1d7c4}', '\u{1d7cb}'), ('\u{1e000}', '\u{1e006}'),
+        ('\u{1e008}', '\u{1e018}'), ('\u{1e01b}', '\u{1e021}'), ('\u{1e023}', '\u{1e024}'),
+        ('\u{1e026}', '\u{1e02a}'), ('\u{1e800}', '\u{1e8c4}'), ('\u{1e900}', '\u{1e943}'),
+        ('\u{1e947}', '\u{1e947}'), ('\u{1ee00}', '\u{1ee03}'), ('\u{1ee05}', '\u{1ee1f}'),
+        ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}', '\u{1ee24}'), ('\u{1ee27}', '\u{1ee27}'),
+        ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}', '\u{1ee37}'), ('\u{1ee39}', '\u{1ee39}'),
+        ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}', '\u{1ee42}'), ('\u{1ee47}', '\u{1ee47}'),
+        ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}', '\u{1ee4b}'), ('\u{1ee4d}', '\u{1ee4f}'),
+        ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}', '\u{1ee54}'), ('\u{1ee57}', '\u{1ee57}'),
+        ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}', '\u{1ee5b}'), ('\u{1ee5d}', '\u{1ee5d}'),
+        ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}', '\u{1ee62}'), ('\u{1ee64}', '\u{1ee64}'),
+        ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}', '\u{1ee72}'), ('\u{1ee74}', '\u{1ee77}'),
+        ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}', '\u{1ee7e}'), ('\u{1ee80}', '\u{1ee89}'),
+        ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}', '\u{1eea3}'), ('\u{1eea5}', '\u{1eea9}'),
+        ('\u{1eeab}', '\u{1eebb}'), ('\u{1f130}', '\u{1f149}'), ('\u{1f150}', '\u{1f169}'),
+        ('\u{1f170}', '\u{1f189}'), ('\u{20000}', '\u{2a6d6}'), ('\u{2a700}', '\u{2b734}'),
+        ('\u{2b740}', '\u{2b81d}'), ('\u{2b820}', '\u{2cea1}'), ('\u{2f800}', '\u{2fa1d}')
+    ];
+
+    #[inline]
+    pub fn Alphabetic(c: char) -> bool {
+        super::util::bsearch_range_table(c, Alphabetic_table)
+    }
+
+}
+
+pub mod grapheme {
+    use core::result::Result::{Ok, Err};
+
+    pub use self::GraphemeCat::*;
+
+    #[allow(non_camel_case_types)]
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub enum GraphemeCat {
+        GC_Any,
+        GC_CR,
+        GC_Control,
+        GC_E_Base,
+        GC_E_Base_GAZ,
+        GC_E_Modifier,
+        GC_Extend,
+        GC_Glue_After_Zwj,
+        GC_L,
+        GC_LF,
+        GC_LV,
+        GC_LVT,
+        GC_Prepend,
+        GC_Regional_Indicator,
+        GC_SpacingMark,
+        GC_T,
+        GC_V,
+        GC_ZWJ,
+    }
+
+    fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        match r.binary_search_by(|&(lo, hi, _)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }) {
+            Ok(idx) => {
+                let (_, _, cat) = r[idx];
+                cat
+            }
+            Err(_) => GC_Any
+        }
+    }
+
+    pub fn grapheme_category(c: char) -> GraphemeCat {
+        bsearch_range_value_table(c, grapheme_cat_table)
+    }
+
+    const grapheme_cat_table: &'static [(char, char, GraphemeCat)] = &[
+        ('\u{0}', '\u{9}', GC_Control), ('\u{a}', '\u{a}', GC_LF), ('\u{b}', '\u{c}', GC_Control),
+        ('\u{d}', '\u{d}', GC_CR), ('\u{e}', '\u{1f}', GC_Control), ('\u{7f}', '\u{9f}',
+        GC_Control), ('\u{ad}', '\u{ad}', GC_Control), ('\u{300}', '\u{36f}', GC_Extend),
+        ('\u{483}', '\u{489}', GC_Extend), ('\u{591}', '\u{5bd}', GC_Extend), ('\u{5bf}', '\u{5bf}',
+        GC_Extend), ('\u{5c1}', '\u{5c2}', GC_Extend), ('\u{5c4}', '\u{5c5}', GC_Extend),
+        ('\u{5c7}', '\u{5c7}', GC_Extend), ('\u{600}', '\u{605}', GC_Prepend), ('\u{610}',
+        '\u{61a}', GC_Extend), ('\u{61c}', '\u{61c}', GC_Control), ('\u{64b}', '\u{65f}',
+        GC_Extend), ('\u{670}', '\u{670}', GC_Extend), ('\u{6d6}', '\u{6dc}', GC_Extend),
+        ('\u{6dd}', '\u{6dd}', GC_Prepend), ('\u{6df}', '\u{6e4}', GC_Extend), ('\u{6e7}',
+        '\u{6e8}', GC_Extend), ('\u{6ea}', '\u{6ed}', GC_Extend), ('\u{70f}', '\u{70f}',
+        GC_Prepend), ('\u{711}', '\u{711}', GC_Extend), ('\u{730}', '\u{74a}', GC_Extend),
+        ('\u{7a6}', '\u{7b0}', GC_Extend), ('\u{7eb}', '\u{7f3}', GC_Extend), ('\u{816}', '\u{819}',
+        GC_Extend), ('\u{81b}', '\u{823}', GC_Extend), ('\u{825}', '\u{827}', GC_Extend),
+        ('\u{829}', '\u{82d}', GC_Extend), ('\u{859}', '\u{85b}', GC_Extend), ('\u{8d4}', '\u{8e1}',
+        GC_Extend), ('\u{8e2}', '\u{8e2}', GC_Prepend), ('\u{8e3}', '\u{902}', GC_Extend),
+        ('\u{903}', '\u{903}', GC_SpacingMark), ('\u{93a}', '\u{93a}', GC_Extend), ('\u{93b}',
+        '\u{93b}', GC_SpacingMark), ('\u{93c}', '\u{93c}', GC_Extend), ('\u{93e}', '\u{940}',
+        GC_SpacingMark), ('\u{941}', '\u{948}', GC_Extend), ('\u{949}', '\u{94c}', GC_SpacingMark),
+        ('\u{94d}', '\u{94d}', GC_Extend), ('\u{94e}', '\u{94f}', GC_SpacingMark), ('\u{951}',
+        '\u{957}', GC_Extend), ('\u{962}', '\u{963}', GC_Extend), ('\u{981}', '\u{981}', GC_Extend),
+        ('\u{982}', '\u{983}', GC_SpacingMark), ('\u{9bc}', '\u{9bc}', GC_Extend), ('\u{9be}',
+        '\u{9be}', GC_Extend), ('\u{9bf}', '\u{9c0}', GC_SpacingMark), ('\u{9c1}', '\u{9c4}',
+        GC_Extend), ('\u{9c7}', '\u{9c8}', GC_SpacingMark), ('\u{9cb}', '\u{9cc}', GC_SpacingMark),
+        ('\u{9cd}', '\u{9cd}', GC_Extend), ('\u{9d7}', '\u{9d7}', GC_Extend), ('\u{9e2}', '\u{9e3}',
+        GC_Extend), ('\u{a01}', '\u{a02}', GC_Extend), ('\u{a03}', '\u{a03}', GC_SpacingMark),
+        ('\u{a3c}', '\u{a3c}', GC_Extend), ('\u{a3e}', '\u{a40}', GC_SpacingMark), ('\u{a41}',
+        '\u{a42}', GC_Extend), ('\u{a47}', '\u{a48}', GC_Extend), ('\u{a4b}', '\u{a4d}', GC_Extend),
+        ('\u{a51}', '\u{a51}', GC_Extend), ('\u{a70}', '\u{a71}', GC_Extend), ('\u{a75}', '\u{a75}',
+        GC_Extend), ('\u{a81}', '\u{a82}', GC_Extend), ('\u{a83}', '\u{a83}', GC_SpacingMark),
+        ('\u{abc}', '\u{abc}', GC_Extend), ('\u{abe}', '\u{ac0}', GC_SpacingMark), ('\u{ac1}',
+        '\u{ac5}', GC_Extend), ('\u{ac7}', '\u{ac8}', GC_Extend), ('\u{ac9}', '\u{ac9}',
+        GC_SpacingMark), ('\u{acb}', '\u{acc}', GC_SpacingMark), ('\u{acd}', '\u{acd}', GC_Extend),
+        ('\u{ae2}', '\u{ae3}', GC_Extend), ('\u{b01}', '\u{b01}', GC_Extend), ('\u{b02}', '\u{b03}',
+        GC_SpacingMark), ('\u{b3c}', '\u{b3c}', GC_Extend), ('\u{b3e}', '\u{b3f}', GC_Extend),
+        ('\u{b40}', '\u{b40}', GC_SpacingMark), ('\u{b41}', '\u{b44}', GC_Extend), ('\u{b47}',
+        '\u{b48}', GC_SpacingMark), ('\u{b4b}', '\u{b4c}', GC_SpacingMark), ('\u{b4d}', '\u{b4d}',
+        GC_Extend), ('\u{b56}', '\u{b57}', GC_Extend), ('\u{b62}', '\u{b63}', GC_Extend),
+        ('\u{b82}', '\u{b82}', GC_Extend), ('\u{bbe}', '\u{bbe}', GC_Extend), ('\u{bbf}', '\u{bbf}',
+        GC_SpacingMark), ('\u{bc0}', '\u{bc0}', GC_Extend), ('\u{bc1}', '\u{bc2}', GC_SpacingMark),
+        ('\u{bc6}', '\u{bc8}', GC_SpacingMark), ('\u{bca}', '\u{bcc}', GC_SpacingMark), ('\u{bcd}',
+        '\u{bcd}', GC_Extend), ('\u{bd7}', '\u{bd7}', GC_Extend), ('\u{c00}', '\u{c00}', GC_Extend),
+        ('\u{c01}', '\u{c03}', GC_SpacingMark), ('\u{c3e}', '\u{c40}', GC_Extend), ('\u{c41}',
+        '\u{c44}', GC_SpacingMark), ('\u{c46}', '\u{c48}', GC_Extend), ('\u{c4a}', '\u{c4d}',
+        GC_Extend), ('\u{c55}', '\u{c56}', GC_Extend), ('\u{c62}', '\u{c63}', GC_Extend),
+        ('\u{c81}', '\u{c81}', GC_Extend), ('\u{c82}', '\u{c83}', GC_SpacingMark), ('\u{cbc}',
+        '\u{cbc}', GC_Extend), ('\u{cbe}', '\u{cbe}', GC_SpacingMark), ('\u{cbf}', '\u{cbf}',
+        GC_Extend), ('\u{cc0}', '\u{cc1}', GC_SpacingMark), ('\u{cc2}', '\u{cc2}', GC_Extend),
+        ('\u{cc3}', '\u{cc4}', GC_SpacingMark), ('\u{cc6}', '\u{cc6}', GC_Extend), ('\u{cc7}',
+        '\u{cc8}', GC_SpacingMark), ('\u{cca}', '\u{ccb}', GC_SpacingMark), ('\u{ccc}', '\u{ccd}',
+        GC_Extend), ('\u{cd5}', '\u{cd6}', GC_Extend), ('\u{ce2}', '\u{ce3}', GC_Extend),
+        ('\u{d01}', '\u{d01}', GC_Extend), ('\u{d02}', '\u{d03}', GC_SpacingMark), ('\u{d3e}',
+        '\u{d3e}', GC_Extend), ('\u{d3f}', '\u{d40}', GC_SpacingMark), ('\u{d41}', '\u{d44}',
+        GC_Extend), ('\u{d46}', '\u{d48}', GC_SpacingMark), ('\u{d4a}', '\u{d4c}', GC_SpacingMark),
+        ('\u{d4d}', '\u{d4d}', GC_Extend), ('\u{d4e}', '\u{d4e}', GC_Prepend), ('\u{d57}',
+        '\u{d57}', GC_Extend), ('\u{d62}', '\u{d63}', GC_Extend), ('\u{d82}', '\u{d83}',
+        GC_SpacingMark), ('\u{dca}', '\u{dca}', GC_Extend), ('\u{dcf}', '\u{dcf}', GC_Extend),
+        ('\u{dd0}', '\u{dd1}', GC_SpacingMark), ('\u{dd2}', '\u{dd4}', GC_Extend), ('\u{dd6}',
+        '\u{dd6}', GC_Extend), ('\u{dd8}', '\u{dde}', GC_SpacingMark), ('\u{ddf}', '\u{ddf}',
+        GC_Extend), ('\u{df2}', '\u{df3}', GC_SpacingMark), ('\u{e31}', '\u{e31}', GC_Extend),
+        ('\u{e33}', '\u{e33}', GC_SpacingMark), ('\u{e34}', '\u{e3a}', GC_Extend), ('\u{e47}',
+        '\u{e4e}', GC_Extend), ('\u{eb1}', '\u{eb1}', GC_Extend), ('\u{eb3}', '\u{eb3}',
+        GC_SpacingMark), ('\u{eb4}', '\u{eb9}', GC_Extend), ('\u{ebb}', '\u{ebc}', GC_Extend),
+        ('\u{ec8}', '\u{ecd}', GC_Extend), ('\u{f18}', '\u{f19}', GC_Extend), ('\u{f35}', '\u{f35}',
+        GC_Extend), ('\u{f37}', '\u{f37}', GC_Extend), ('\u{f39}', '\u{f39}', GC_Extend),
+        ('\u{f3e}', '\u{f3f}', GC_SpacingMark), ('\u{f71}', '\u{f7e}', GC_Extend), ('\u{f7f}',
+        '\u{f7f}', GC_SpacingMark), ('\u{f80}', '\u{f84}', GC_Extend), ('\u{f86}', '\u{f87}',
+        GC_Extend), ('\u{f8d}', '\u{f97}', GC_Extend), ('\u{f99}', '\u{fbc}', GC_Extend),
+        ('\u{fc6}', '\u{fc6}', GC_Extend), ('\u{102d}', '\u{1030}', GC_Extend), ('\u{1031}',
+        '\u{1031}', GC_SpacingMark), ('\u{1032}', '\u{1037}', GC_Extend), ('\u{1039}', '\u{103a}',
+        GC_Extend), ('\u{103b}', '\u{103c}', GC_SpacingMark), ('\u{103d}', '\u{103e}', GC_Extend),
+        ('\u{1056}', '\u{1057}', GC_SpacingMark), ('\u{1058}', '\u{1059}', GC_Extend), ('\u{105e}',
+        '\u{1060}', GC_Extend), ('\u{1071}', '\u{1074}', GC_Extend), ('\u{1082}', '\u{1082}',
+        GC_Extend), ('\u{1084}', '\u{1084}', GC_SpacingMark), ('\u{1085}', '\u{1086}', GC_Extend),
+        ('\u{108d}', '\u{108d}', GC_Extend), ('\u{109d}', '\u{109d}', GC_Extend), ('\u{1100}',
+        '\u{115f}', GC_L), ('\u{1160}', '\u{11a7}', GC_V), ('\u{11a8}', '\u{11ff}', GC_T),
+        ('\u{135d}', '\u{135f}', GC_Extend), ('\u{1712}', '\u{1714}', GC_Extend), ('\u{1732}',
+        '\u{1734}', GC_Extend), ('\u{1752}', '\u{1753}', GC_Extend), ('\u{1772}', '\u{1773}',
+        GC_Extend), ('\u{17b4}', '\u{17b5}', GC_Extend), ('\u{17b6}', '\u{17b6}', GC_SpacingMark),
+        ('\u{17b7}', '\u{17bd}', GC_Extend), ('\u{17be}', '\u{17c5}', GC_SpacingMark), ('\u{17c6}',
+        '\u{17c6}', GC_Extend), ('\u{17c7}', '\u{17c8}', GC_SpacingMark), ('\u{17c9}', '\u{17d3}',
+        GC_Extend), ('\u{17dd}', '\u{17dd}', GC_Extend), ('\u{180b}', '\u{180d}', GC_Extend),
+        ('\u{180e}', '\u{180e}', GC_Control), ('\u{1885}', '\u{1886}', GC_Extend), ('\u{18a9}',
+        '\u{18a9}', GC_Extend), ('\u{1920}', '\u{1922}', GC_Extend), ('\u{1923}', '\u{1926}',
+        GC_SpacingMark), ('\u{1927}', '\u{1928}', GC_Extend), ('\u{1929}', '\u{192b}',
+        GC_SpacingMark), ('\u{1930}', '\u{1931}', GC_SpacingMark), ('\u{1932}', '\u{1932}',
+        GC_Extend), ('\u{1933}', '\u{1938}', GC_SpacingMark), ('\u{1939}', '\u{193b}', GC_Extend),
+        ('\u{1a17}', '\u{1a18}', GC_Extend), ('\u{1a19}', '\u{1a1a}', GC_SpacingMark), ('\u{1a1b}',
+        '\u{1a1b}', GC_Extend), ('\u{1a55}', '\u{1a55}', GC_SpacingMark), ('\u{1a56}', '\u{1a56}',
+        GC_Extend), ('\u{1a57}', '\u{1a57}', GC_SpacingMark), ('\u{1a58}', '\u{1a5e}', GC_Extend),
+        ('\u{1a60}', '\u{1a60}', GC_Extend), ('\u{1a62}', '\u{1a62}', GC_Extend), ('\u{1a65}',
+        '\u{1a6c}', GC_Extend), ('\u{1a6d}', '\u{1a72}', GC_SpacingMark), ('\u{1a73}', '\u{1a7c}',
+        GC_Extend), ('\u{1a7f}', '\u{1a7f}', GC_Extend), ('\u{1ab0}', '\u{1abe}', GC_Extend),
+        ('\u{1b00}', '\u{1b03}', GC_Extend), ('\u{1b04}', '\u{1b04}', GC_SpacingMark), ('\u{1b34}',
+        '\u{1b34}', GC_Extend), ('\u{1b35}', '\u{1b35}', GC_SpacingMark), ('\u{1b36}', '\u{1b3a}',
+        GC_Extend), ('\u{1b3b}', '\u{1b3b}', GC_SpacingMark), ('\u{1b3c}', '\u{1b3c}', GC_Extend),
+        ('\u{1b3d}', '\u{1b41}', GC_SpacingMark), ('\u{1b42}', '\u{1b42}', GC_Extend), ('\u{1b43}',
+        '\u{1b44}', GC_SpacingMark), ('\u{1b6b}', '\u{1b73}', GC_Extend), ('\u{1b80}', '\u{1b81}',
+        GC_Extend), ('\u{1b82}', '\u{1b82}', GC_SpacingMark), ('\u{1ba1}', '\u{1ba1}',
+        GC_SpacingMark), ('\u{1ba2}', '\u{1ba5}', GC_Extend), ('\u{1ba6}', '\u{1ba7}',
+        GC_SpacingMark), ('\u{1ba8}', '\u{1ba9}', GC_Extend), ('\u{1baa}', '\u{1baa}',
+        GC_SpacingMark), ('\u{1bab}', '\u{1bad}', GC_Extend), ('\u{1be6}', '\u{1be6}', GC_Extend),
+        ('\u{1be7}', '\u{1be7}', GC_SpacingMark), ('\u{1be8}', '\u{1be9}', GC_Extend), ('\u{1bea}',
+        '\u{1bec}', GC_SpacingMark), ('\u{1bed}', '\u{1bed}', GC_Extend), ('\u{1bee}', '\u{1bee}',
+        GC_SpacingMark), ('\u{1bef}', '\u{1bf1}', GC_Extend), ('\u{1bf2}', '\u{1bf3}',
+        GC_SpacingMark), ('\u{1c24}', '\u{1c2b}', GC_SpacingMark), ('\u{1c2c}', '\u{1c33}',
+        GC_Extend), ('\u{1c34}', '\u{1c35}', GC_SpacingMark), ('\u{1c36}', '\u{1c37}', GC_Extend),
+        ('\u{1cd0}', '\u{1cd2}', GC_Extend), ('\u{1cd4}', '\u{1ce0}', GC_Extend), ('\u{1ce1}',
+        '\u{1ce1}', GC_SpacingMark), ('\u{1ce2}', '\u{1ce8}', GC_Extend), ('\u{1ced}', '\u{1ced}',
+        GC_Extend), ('\u{1cf2}', '\u{1cf3}', GC_SpacingMark), ('\u{1cf4}', '\u{1cf4}', GC_Extend),
+        ('\u{1cf8}', '\u{1cf9}', GC_Extend), ('\u{1dc0}', '\u{1df5}', GC_Extend), ('\u{1dfb}',
+        '\u{1dff}', GC_Extend), ('\u{200b}', '\u{200b}', GC_Control), ('\u{200c}', '\u{200c}',
+        GC_Extend), ('\u{200d}', '\u{200d}', GC_ZWJ), ('\u{200e}', '\u{200f}', GC_Control),
+        ('\u{2028}', '\u{202e}', GC_Control), ('\u{2060}', '\u{206f}', GC_Control), ('\u{20d0}',
+        '\u{20f0}', GC_Extend), ('\u{261d}', '\u{261d}', GC_E_Base), ('\u{26f9}', '\u{26f9}',
+        GC_E_Base), ('\u{270a}', '\u{270d}', GC_E_Base), ('\u{2764}', '\u{2764}',
+        GC_Glue_After_Zwj), ('\u{2cef}', '\u{2cf1}', GC_Extend), ('\u{2d7f}', '\u{2d7f}',
+        GC_Extend), ('\u{2de0}', '\u{2dff}', GC_Extend), ('\u{302a}', '\u{302f}', GC_Extend),
+        ('\u{3099}', '\u{309a}', GC_Extend), ('\u{a66f}', '\u{a672}', GC_Extend), ('\u{a674}',
+        '\u{a67d}', GC_Extend), ('\u{a69e}', '\u{a69f}', GC_Extend), ('\u{a6f0}', '\u{a6f1}',
+        GC_Extend), ('\u{a802}', '\u{a802}', GC_Extend), ('\u{a806}', '\u{a806}', GC_Extend),
+        ('\u{a80b}', '\u{a80b}', GC_Extend), ('\u{a823}', '\u{a824}', GC_SpacingMark), ('\u{a825}',
+        '\u{a826}', GC_Extend), ('\u{a827}', '\u{a827}', GC_SpacingMark), ('\u{a880}', '\u{a881}',
+        GC_SpacingMark), ('\u{a8b4}', '\u{a8c3}', GC_SpacingMark), ('\u{a8c4}', '\u{a8c5}',
+        GC_Extend), ('\u{a8e0}', '\u{a8f1}', GC_Extend), ('\u{a926}', '\u{a92d}', GC_Extend),
+        ('\u{a947}', '\u{a951}', GC_Extend), ('\u{a952}', '\u{a953}', GC_SpacingMark), ('\u{a960}',
+        '\u{a97c}', GC_L), ('\u{a980}', '\u{a982}', GC_Extend), ('\u{a983}', '\u{a983}',
+        GC_SpacingMark), ('\u{a9b3}', '\u{a9b3}', GC_Extend), ('\u{a9b4}', '\u{a9b5}',
+        GC_SpacingMark), ('\u{a9b6}', '\u{a9b9}', GC_Extend), ('\u{a9ba}', '\u{a9bb}',
+        GC_SpacingMark), ('\u{a9bc}', '\u{a9bc}', GC_Extend), ('\u{a9bd}', '\u{a9c0}',
+        GC_SpacingMark), ('\u{a9e5}', '\u{a9e5}', GC_Extend), ('\u{aa29}', '\u{aa2e}', GC_Extend),
+        ('\u{aa2f}', '\u{aa30}', GC_SpacingMark), ('\u{aa31}', '\u{aa32}', GC_Extend), ('\u{aa33}',
+        '\u{aa34}', GC_SpacingMark), ('\u{aa35}', '\u{aa36}', GC_Extend), ('\u{aa43}', '\u{aa43}',
+        GC_Extend), ('\u{aa4c}', '\u{aa4c}', GC_Extend), ('\u{aa4d}', '\u{aa4d}', GC_SpacingMark),
+        ('\u{aa7c}', '\u{aa7c}', GC_Extend), ('\u{aab0}', '\u{aab0}', GC_Extend), ('\u{aab2}',
+        '\u{aab4}', GC_Extend), ('\u{aab7}', '\u{aab8}', GC_Extend), ('\u{aabe}', '\u{aabf}',
+        GC_Extend), ('\u{aac1}', '\u{aac1}', GC_Extend), ('\u{aaeb}', '\u{aaeb}', GC_SpacingMark),
+        ('\u{aaec}', '\u{aaed}', GC_Extend), ('\u{aaee}', '\u{aaef}', GC_SpacingMark), ('\u{aaf5}',
+        '\u{aaf5}', GC_SpacingMark), ('\u{aaf6}', '\u{aaf6}', GC_Extend), ('\u{abe3}', '\u{abe4}',
+        GC_SpacingMark), ('\u{abe5}', '\u{abe5}', GC_Extend), ('\u{abe6}', '\u{abe7}',
+        GC_SpacingMark), ('\u{abe8}', '\u{abe8}', GC_Extend), ('\u{abe9}', '\u{abea}',
+        GC_SpacingMark), ('\u{abec}', '\u{abec}', GC_SpacingMark), ('\u{abed}', '\u{abed}',
+        GC_Extend), ('\u{ac00}', '\u{ac00}', GC_LV), ('\u{ac01}', '\u{ac1b}', GC_LVT), ('\u{ac1c}',
+        '\u{ac1c}', GC_LV), ('\u{ac1d}', '\u{ac37}', GC_LVT), ('\u{ac38}', '\u{ac38}', GC_LV),
+        ('\u{ac39}', '\u{ac53}', GC_LVT), ('\u{ac54}', '\u{ac54}', GC_LV), ('\u{ac55}', '\u{ac6f}',
+        GC_LVT), ('\u{ac70}', '\u{ac70}', GC_LV), ('\u{ac71}', '\u{ac8b}', GC_LVT), ('\u{ac8c}',
+        '\u{ac8c}', GC_LV), ('\u{ac8d}', '\u{aca7}', GC_LVT), ('\u{aca8}', '\u{aca8}', GC_LV),
+        ('\u{aca9}', '\u{acc3}', GC_LVT), ('\u{acc4}', '\u{acc4}', GC_LV), ('\u{acc5}', '\u{acdf}',
+        GC_LVT), ('\u{ace0}', '\u{ace0}', GC_LV), ('\u{ace1}', '\u{acfb}', GC_LVT), ('\u{acfc}',
+        '\u{acfc}', GC_LV), ('\u{acfd}', '\u{ad17}', GC_LVT), ('\u{ad18}', '\u{ad18}', GC_LV),
+        ('\u{ad19}', '\u{ad33}', GC_LVT), ('\u{ad34}', '\u{ad34}', GC_LV), ('\u{ad35}', '\u{ad4f}',
+        GC_LVT), ('\u{ad50}', '\u{ad50}', GC_LV), ('\u{ad51}', '\u{ad6b}', GC_LVT), ('\u{ad6c}',
+        '\u{ad6c}', GC_LV), ('\u{ad6d}', '\u{ad87}', GC_LVT), ('\u{ad88}', '\u{ad88}', GC_LV),
+        ('\u{ad89}', '\u{ada3}', GC_LVT), ('\u{ada4}', '\u{ada4}', GC_LV), ('\u{ada5}', '\u{adbf}',
+        GC_LVT), ('\u{adc0}', '\u{adc0}', GC_LV), ('\u{adc1}', '\u{addb}', GC_LVT), ('\u{addc}',
+        '\u{addc}', GC_LV), ('\u{addd}', '\u{adf7}', GC_LVT), ('\u{adf8}', '\u{adf8}', GC_LV),
+        ('\u{adf9}', '\u{ae13}', GC_LVT), ('\u{ae14}', '\u{ae14}', GC_LV), ('\u{ae15}', '\u{ae2f}',
+        GC_LVT), ('\u{ae30}', '\u{ae30}', GC_LV), ('\u{ae31}', '\u{ae4b}', GC_LVT), ('\u{ae4c}',
+        '\u{ae4c}', GC_LV), ('\u{ae4d}', '\u{ae67}', GC_LVT), ('\u{ae68}', '\u{ae68}', GC_LV),
+        ('\u{ae69}', '\u{ae83}', GC_LVT), ('\u{ae84}', '\u{ae84}', GC_LV), ('\u{ae85}', '\u{ae9f}',
+        GC_LVT), ('\u{aea0}', '\u{aea0}', GC_LV), ('\u{aea1}', '\u{aebb}', GC_LVT), ('\u{aebc}',
+        '\u{aebc}', GC_LV), ('\u{aebd}', '\u{aed7}', GC_LVT), ('\u{aed8}', '\u{aed8}', GC_LV),
+        ('\u{aed9}', '\u{aef3}', GC_LVT), ('\u{aef4}', '\u{aef4}', GC_LV), ('\u{aef5}', '\u{af0f}',
+        GC_LVT), ('\u{af10}', '\u{af10}', GC_LV), ('\u{af11}', '\u{af2b}', GC_LVT), ('\u{af2c}',
+        '\u{af2c}', GC_LV), ('\u{af2d}', '\u{af47}', GC_LVT), ('\u{af48}', '\u{af48}', GC_LV),
+        ('\u{af49}', '\u{af63}', GC_LVT), ('\u{af64}', '\u{af64}', GC_LV), ('\u{af65}', '\u{af7f}',
+        GC_LVT), ('\u{af80}', '\u{af80}', GC_LV), ('\u{af81}', '\u{af9b}', GC_LVT), ('\u{af9c}',
+        '\u{af9c}', GC_LV), ('\u{af9d}', '\u{afb7}', GC_LVT), ('\u{afb8}', '\u{afb8}', GC_LV),
+        ('\u{afb9}', '\u{afd3}', GC_LVT), ('\u{afd4}', '\u{afd4}', GC_LV), ('\u{afd5}', '\u{afef}',
+        GC_LVT), ('\u{aff0}', '\u{aff0}', GC_LV), ('\u{aff1}', '\u{b00b}', GC_LVT), ('\u{b00c}',
+        '\u{b00c}', GC_LV), ('\u{b00d}', '\u{b027}', GC_LVT), ('\u{b028}', '\u{b028}', GC_LV),
+        ('\u{b029}', '\u{b043}', GC_LVT), ('\u{b044}', '\u{b044}', GC_LV), ('\u{b045}', '\u{b05f}',
+        GC_LVT), ('\u{b060}', '\u{b060}', GC_LV), ('\u{b061}', '\u{b07b}', GC_LVT), ('\u{b07c}',
+        '\u{b07c}', GC_LV), ('\u{b07d}', '\u{b097}', GC_LVT), ('\u{b098}', '\u{b098}', GC_LV),
+        ('\u{b099}', '\u{b0b3}', GC_LVT), ('\u{b0b4}', '\u{b0b4}', GC_LV), ('\u{b0b5}', '\u{b0cf}',
+        GC_LVT), ('\u{b0d0}', '\u{b0d0}', GC_LV), ('\u{b0d1}', '\u{b0eb}', GC_LVT), ('\u{b0ec}',
+        '\u{b0ec}', GC_LV), ('\u{b0ed}', '\u{b107}', GC_LVT), ('\u{b108}', '\u{b108}', GC_LV),
+        ('\u{b109}', '\u{b123}', GC_LVT), ('\u{b124}', '\u{b124}', GC_LV), ('\u{b125}', '\u{b13f}',
+        GC_LVT), ('\u{b140}', '\u{b140}', GC_LV), ('\u{b141}', '\u{b15b}', GC_LVT), ('\u{b15c}',
+        '\u{b15c}', GC_LV), ('\u{b15d}', '\u{b177}', GC_LVT), ('\u{b178}', '\u{b178}', GC_LV),
+        ('\u{b179}', '\u{b193}', GC_LVT), ('\u{b194}', '\u{b194}', GC_LV), ('\u{b195}', '\u{b1af}',
+        GC_LVT), ('\u{b1b0}', '\u{b1b0}', GC_LV), ('\u{b1b1}', '\u{b1cb}', GC_LVT), ('\u{b1cc}',
+        '\u{b1cc}', GC_LV), ('\u{b1cd}', '\u{b1e7}', GC_LVT), ('\u{b1e8}', '\u{b1e8}', GC_LV),
+        ('\u{b1e9}', '\u{b203}', GC_LVT), ('\u{b204}', '\u{b204}', GC_LV), ('\u{b205}', '\u{b21f}',
+        GC_LVT), ('\u{b220}', '\u{b220}', GC_LV), ('\u{b221}', '\u{b23b}', GC_LVT), ('\u{b23c}',
+        '\u{b23c}', GC_LV), ('\u{b23d}', '\u{b257}', GC_LVT), ('\u{b258}', '\u{b258}', GC_LV),
+        ('\u{b259}', '\u{b273}', GC_LVT), ('\u{b274}', '\u{b274}', GC_LV), ('\u{b275}', '\u{b28f}',
+        GC_LVT), ('\u{b290}', '\u{b290}', GC_LV), ('\u{b291}', '\u{b2ab}', GC_LVT), ('\u{b2ac}',
+        '\u{b2ac}', GC_LV), ('\u{b2ad}', '\u{b2c7}', GC_LVT), ('\u{b2c8}', '\u{b2c8}', GC_LV),
+        ('\u{b2c9}', '\u{b2e3}', GC_LVT), ('\u{b2e4}', '\u{b2e4}', GC_LV), ('\u{b2e5}', '\u{b2ff}',
+        GC_LVT), ('\u{b300}', '\u{b300}', GC_LV), ('\u{b301}', '\u{b31b}', GC_LVT), ('\u{b31c}',
+        '\u{b31c}', GC_LV), ('\u{b31d}', '\u{b337}', GC_LVT), ('\u{b338}', '\u{b338}', GC_LV),
+        ('\u{b339}', '\u{b353}', GC_LVT), ('\u{b354}', '\u{b354}', GC_LV), ('\u{b355}', '\u{b36f}',
+        GC_LVT), ('\u{b370}', '\u{b370}', GC_LV), ('\u{b371}', '\u{b38b}', GC_LVT), ('\u{b38c}',
+        '\u{b38c}', GC_LV), ('\u{b38d}', '\u{b3a7}', GC_LVT), ('\u{b3a8}', '\u{b3a8}', GC_LV),
+        ('\u{b3a9}', '\u{b3c3}', GC_LVT), ('\u{b3c4}', '\u{b3c4}', GC_LV), ('\u{b3c5}', '\u{b3df}',
+        GC_LVT), ('\u{b3e0}', '\u{b3e0}', GC_LV), ('\u{b3e1}', '\u{b3fb}', GC_LVT), ('\u{b3fc}',
+        '\u{b3fc}', GC_LV), ('\u{b3fd}', '\u{b417}', GC_LVT), ('\u{b418}', '\u{b418}', GC_LV),
+        ('\u{b419}', '\u{b433}', GC_LVT), ('\u{b434}', '\u{b434}', GC_LV), ('\u{b435}', '\u{b44f}',
+        GC_LVT), ('\u{b450}', '\u{b450}', GC_LV), ('\u{b451}', '\u{b46b}', GC_LVT), ('\u{b46c}',
+        '\u{b46c}', GC_LV), ('\u{b46d}', '\u{b487}', GC_LVT), ('\u{b488}', '\u{b488}', GC_LV),
+        ('\u{b489}', '\u{b4a3}', GC_LVT), ('\u{b4a4}', '\u{b4a4}', GC_LV), ('\u{b4a5}', '\u{b4bf}',
+        GC_LVT), ('\u{b4c0}', '\u{b4c0}', GC_LV), ('\u{b4c1}', '\u{b4db}', GC_LVT), ('\u{b4dc}',
+        '\u{b4dc}', GC_LV), ('\u{b4dd}', '\u{b4f7}', GC_LVT), ('\u{b4f8}', '\u{b4f8}', GC_LV),
+        ('\u{b4f9}', '\u{b513}', GC_LVT), ('\u{b514}', '\u{b514}', GC_LV), ('\u{b515}', '\u{b52f}',
+        GC_LVT), ('\u{b530}', '\u{b530}', GC_LV), ('\u{b531}', '\u{b54b}', GC_LVT), ('\u{b54c}',
+        '\u{b54c}', GC_LV), ('\u{b54d}', '\u{b567}', GC_LVT), ('\u{b568}', '\u{b568}', GC_LV),
+        ('\u{b569}', '\u{b583}', GC_LVT), ('\u{b584}', '\u{b584}', GC_LV), ('\u{b585}', '\u{b59f}',
+        GC_LVT), ('\u{b5a0}', '\u{b5a0}', GC_LV), ('\u{b5a1}', '\u{b5bb}', GC_LVT), ('\u{b5bc}',
+        '\u{b5bc}', GC_LV), ('\u{b5bd}', '\u{b5d7}', GC_LVT), ('\u{b5d8}', '\u{b5d8}', GC_LV),
+        ('\u{b5d9}', '\u{b5f3}', GC_LVT), ('\u{b5f4}', '\u{b5f4}', GC_LV), ('\u{b5f5}', '\u{b60f}',
+        GC_LVT), ('\u{b610}', '\u{b610}', GC_LV), ('\u{b611}', '\u{b62b}', GC_LVT), ('\u{b62c}',
+        '\u{b62c}', GC_LV), ('\u{b62d}', '\u{b647}', GC_LVT), ('\u{b648}', '\u{b648}', GC_LV),
+        ('\u{b649}', '\u{b663}', GC_LVT), ('\u{b664}', '\u{b664}', GC_LV), ('\u{b665}', '\u{b67f}',
+        GC_LVT), ('\u{b680}', '\u{b680}', GC_LV), ('\u{b681}', '\u{b69b}', GC_LVT), ('\u{b69c}',
+        '\u{b69c}', GC_LV), ('\u{b69d}', '\u{b6b7}', GC_LVT), ('\u{b6b8}', '\u{b6b8}', GC_LV),
+        ('\u{b6b9}', '\u{b6d3}', GC_LVT), ('\u{b6d4}', '\u{b6d4}', GC_LV), ('\u{b6d5}', '\u{b6ef}',
+        GC_LVT), ('\u{b6f0}', '\u{b6f0}', GC_LV), ('\u{b6f1}', '\u{b70b}', GC_LVT), ('\u{b70c}',
+        '\u{b70c}', GC_LV), ('\u{b70d}', '\u{b727}', GC_LVT), ('\u{b728}', '\u{b728}', GC_LV),
+        ('\u{b729}', '\u{b743}', GC_LVT), ('\u{b744}', '\u{b744}', GC_LV), ('\u{b745}', '\u{b75f}',
+        GC_LVT), ('\u{b760}', '\u{b760}', GC_LV), ('\u{b761}', '\u{b77b}', GC_LVT), ('\u{b77c}',
+        '\u{b77c}', GC_LV), ('\u{b77d}', '\u{b797}', GC_LVT), ('\u{b798}', '\u{b798}', GC_LV),
+        ('\u{b799}', '\u{b7b3}', GC_LVT), ('\u{b7b4}', '\u{b7b4}', GC_LV), ('\u{b7b5}', '\u{b7cf}',
+        GC_LVT), ('\u{b7d0}', '\u{b7d0}', GC_LV), ('\u{b7d1}', '\u{b7eb}', GC_LVT), ('\u{b7ec}',
+        '\u{b7ec}', GC_LV), ('\u{b7ed}', '\u{b807}', GC_LVT), ('\u{b808}', '\u{b808}', GC_LV),
+        ('\u{b809}', '\u{b823}', GC_LVT), ('\u{b824}', '\u{b824}', GC_LV), ('\u{b825}', '\u{b83f}',
+        GC_LVT), ('\u{b840}', '\u{b840}', GC_LV), ('\u{b841}', '\u{b85b}', GC_LVT), ('\u{b85c}',
+        '\u{b85c}', GC_LV), ('\u{b85d}', '\u{b877}', GC_LVT), ('\u{b878}', '\u{b878}', GC_LV),
+        ('\u{b879}', '\u{b893}', GC_LVT), ('\u{b894}', '\u{b894}', GC_LV), ('\u{b895}', '\u{b8af}',
+        GC_LVT), ('\u{b8b0}', '\u{b8b0}', GC_LV), ('\u{b8b1}', '\u{b8cb}', GC_LVT), ('\u{b8cc}',
+        '\u{b8cc}', GC_LV), ('\u{b8cd}', '\u{b8e7}', GC_LVT), ('\u{b8e8}', '\u{b8e8}', GC_LV),
+        ('\u{b8e9}', '\u{b903}', GC_LVT), ('\u{b904}', '\u{b904}', GC_LV), ('\u{b905}', '\u{b91f}',
+        GC_LVT), ('\u{b920}', '\u{b920}', GC_LV), ('\u{b921}', '\u{b93b}', GC_LVT), ('\u{b93c}',
+        '\u{b93c}', GC_LV), ('\u{b93d}', '\u{b957}', GC_LVT), ('\u{b958}', '\u{b958}', GC_LV),
+        ('\u{b959}', '\u{b973}', GC_LVT), ('\u{b974}', '\u{b974}', GC_LV), ('\u{b975}', '\u{b98f}',
+        GC_LVT), ('\u{b990}', '\u{b990}', GC_LV), ('\u{b991}', '\u{b9ab}', GC_LVT), ('\u{b9ac}',
+        '\u{b9ac}', GC_LV), ('\u{b9ad}', '\u{b9c7}', GC_LVT), ('\u{b9c8}', '\u{b9c8}', GC_LV),
+        ('\u{b9c9}', '\u{b9e3}', GC_LVT), ('\u{b9e4}', '\u{b9e4}', GC_LV), ('\u{b9e5}', '\u{b9ff}',
+        GC_LVT), ('\u{ba00}', '\u{ba00}', GC_LV), ('\u{ba01}', '\u{ba1b}', GC_LVT), ('\u{ba1c}',
+        '\u{ba1c}', GC_LV), ('\u{ba1d}', '\u{ba37}', GC_LVT), ('\u{ba38}', '\u{ba38}', GC_LV),
+        ('\u{ba39}', '\u{ba53}', GC_LVT), ('\u{ba54}', '\u{ba54}', GC_LV), ('\u{ba55}', '\u{ba6f}',
+        GC_LVT), ('\u{ba70}', '\u{ba70}', GC_LV), ('\u{ba71}', '\u{ba8b}', GC_LVT), ('\u{ba8c}',
+        '\u{ba8c}', GC_LV), ('\u{ba8d}', '\u{baa7}', GC_LVT), ('\u{baa8}', '\u{baa8}', GC_LV),
+        ('\u{baa9}', '\u{bac3}', GC_LVT), ('\u{bac4}', '\u{bac4}', GC_LV), ('\u{bac5}', '\u{badf}',
+        GC_LVT), ('\u{bae0}', '\u{bae0}', GC_LV), ('\u{bae1}', '\u{bafb}', GC_LVT), ('\u{bafc}',
+        '\u{bafc}', GC_LV), ('\u{bafd}', '\u{bb17}', GC_LVT), ('\u{bb18}', '\u{bb18}', GC_LV),
+        ('\u{bb19}', '\u{bb33}', GC_LVT), ('\u{bb34}', '\u{bb34}', GC_LV), ('\u{bb35}', '\u{bb4f}',
+        GC_LVT), ('\u{bb50}', '\u{bb50}', GC_LV), ('\u{bb51}', '\u{bb6b}', GC_LVT), ('\u{bb6c}',
+        '\u{bb6c}', GC_LV), ('\u{bb6d}', '\u{bb87}', GC_LVT), ('\u{bb88}', '\u{bb88}', GC_LV),
+        ('\u{bb89}', '\u{bba3}', GC_LVT), ('\u{bba4}', '\u{bba4}', GC_LV), ('\u{bba5}', '\u{bbbf}',
+        GC_LVT), ('\u{bbc0}', '\u{bbc0}', GC_LV), ('\u{bbc1}', '\u{bbdb}', GC_LVT), ('\u{bbdc}',
+        '\u{bbdc}', GC_LV), ('\u{bbdd}', '\u{bbf7}', GC_LVT), ('\u{bbf8}', '\u{bbf8}', GC_LV),
+        ('\u{bbf9}', '\u{bc13}', GC_LVT), ('\u{bc14}', '\u{bc14}', GC_LV), ('\u{bc15}', '\u{bc2f}',
+        GC_LVT), ('\u{bc30}', '\u{bc30}', GC_LV), ('\u{bc31}', '\u{bc4b}', GC_LVT), ('\u{bc4c}',
+        '\u{bc4c}', GC_LV), ('\u{bc4d}', '\u{bc67}', GC_LVT), ('\u{bc68}', '\u{bc68}', GC_LV),
+        ('\u{bc69}', '\u{bc83}', GC_LVT), ('\u{bc84}', '\u{bc84}', GC_LV), ('\u{bc85}', '\u{bc9f}',
+        GC_LVT), ('\u{bca0}', '\u{bca0}', GC_LV), ('\u{bca1}', '\u{bcbb}', GC_LVT), ('\u{bcbc}',
+        '\u{bcbc}', GC_LV), ('\u{bcbd}', '\u{bcd7}', GC_LVT), ('\u{bcd8}', '\u{bcd8}', GC_LV),
+        ('\u{bcd9}', '\u{bcf3}', GC_LVT), ('\u{bcf4}', '\u{bcf4}', GC_LV), ('\u{bcf5}', '\u{bd0f}',
+        GC_LVT), ('\u{bd10}', '\u{bd10}', GC_LV), ('\u{bd11}', '\u{bd2b}', GC_LVT), ('\u{bd2c}',
+        '\u{bd2c}', GC_LV), ('\u{bd2d}', '\u{bd47}', GC_LVT), ('\u{bd48}', '\u{bd48}', GC_LV),
+        ('\u{bd49}', '\u{bd63}', GC_LVT), ('\u{bd64}', '\u{bd64}', GC_LV), ('\u{bd65}', '\u{bd7f}',
+        GC_LVT), ('\u{bd80}', '\u{bd80}', GC_LV), ('\u{bd81}', '\u{bd9b}', GC_LVT), ('\u{bd9c}',
+        '\u{bd9c}', GC_LV), ('\u{bd9d}', '\u{bdb7}', GC_LVT), ('\u{bdb8}', '\u{bdb8}', GC_LV),
+        ('\u{bdb9}', '\u{bdd3}', GC_LVT), ('\u{bdd4}', '\u{bdd4}', GC_LV), ('\u{bdd5}', '\u{bdef}',
+        GC_LVT), ('\u{bdf0}', '\u{bdf0}', GC_LV), ('\u{bdf1}', '\u{be0b}', GC_LVT), ('\u{be0c}',
+        '\u{be0c}', GC_LV), ('\u{be0d}', '\u{be27}', GC_LVT), ('\u{be28}', '\u{be28}', GC_LV),
+        ('\u{be29}', '\u{be43}', GC_LVT), ('\u{be44}', '\u{be44}', GC_LV), ('\u{be45}', '\u{be5f}',
+        GC_LVT), ('\u{be60}', '\u{be60}', GC_LV), ('\u{be61}', '\u{be7b}', GC_LVT), ('\u{be7c}',
+        '\u{be7c}', GC_LV), ('\u{be7d}', '\u{be97}', GC_LVT), ('\u{be98}', '\u{be98}', GC_LV),
+        ('\u{be99}', '\u{beb3}', GC_LVT), ('\u{beb4}', '\u{beb4}', GC_LV), ('\u{beb5}', '\u{becf}',
+        GC_LVT), ('\u{bed0}', '\u{bed0}', GC_LV), ('\u{bed1}', '\u{beeb}', GC_LVT), ('\u{beec}',
+        '\u{beec}', GC_LV), ('\u{beed}', '\u{bf07}', GC_LVT), ('\u{bf08}', '\u{bf08}', GC_LV),
+        ('\u{bf09}', '\u{bf23}', GC_LVT), ('\u{bf24}', '\u{bf24}', GC_LV), ('\u{bf25}', '\u{bf3f}',
+        GC_LVT), ('\u{bf40}', '\u{bf40}', GC_LV), ('\u{bf41}', '\u{bf5b}', GC_LVT), ('\u{bf5c}',
+        '\u{bf5c}', GC_LV), ('\u{bf5d}', '\u{bf77}', GC_LVT), ('\u{bf78}', '\u{bf78}', GC_LV),
+        ('\u{bf79}', '\u{bf93}', GC_LVT), ('\u{bf94}', '\u{bf94}', GC_LV), ('\u{bf95}', '\u{bfaf}',
+        GC_LVT), ('\u{bfb0}', '\u{bfb0}', GC_LV), ('\u{bfb1}', '\u{bfcb}', GC_LVT), ('\u{bfcc}',
+        '\u{bfcc}', GC_LV), ('\u{bfcd}', '\u{bfe7}', GC_LVT), ('\u{bfe8}', '\u{bfe8}', GC_LV),
+        ('\u{bfe9}', '\u{c003}', GC_LVT), ('\u{c004}', '\u{c004}', GC_LV), ('\u{c005}', '\u{c01f}',
+        GC_LVT), ('\u{c020}', '\u{c020}', GC_LV), ('\u{c021}', '\u{c03b}', GC_LVT), ('\u{c03c}',
+        '\u{c03c}', GC_LV), ('\u{c03d}', '\u{c057}', GC_LVT), ('\u{c058}', '\u{c058}', GC_LV),
+        ('\u{c059}', '\u{c073}', GC_LVT), ('\u{c074}', '\u{c074}', GC_LV), ('\u{c075}', '\u{c08f}',
+        GC_LVT), ('\u{c090}', '\u{c090}', GC_LV), ('\u{c091}', '\u{c0ab}', GC_LVT), ('\u{c0ac}',
+        '\u{c0ac}', GC_LV), ('\u{c0ad}', '\u{c0c7}', GC_LVT), ('\u{c0c8}', '\u{c0c8}', GC_LV),
+        ('\u{c0c9}', '\u{c0e3}', GC_LVT), ('\u{c0e4}', '\u{c0e4}', GC_LV), ('\u{c0e5}', '\u{c0ff}',
+        GC_LVT), ('\u{c100}', '\u{c100}', GC_LV), ('\u{c101}', '\u{c11b}', GC_LVT), ('\u{c11c}',
+        '\u{c11c}', GC_LV), ('\u{c11d}', '\u{c137}', GC_LVT), ('\u{c138}', '\u{c138}', GC_LV),
+        ('\u{c139}', '\u{c153}', GC_LVT), ('\u{c154}', '\u{c154}', GC_LV), ('\u{c155}', '\u{c16f}',
+        GC_LVT), ('\u{c170}', '\u{c170}', GC_LV), ('\u{c171}', '\u{c18b}', GC_LVT), ('\u{c18c}',
+        '\u{c18c}', GC_LV), ('\u{c18d}', '\u{c1a7}', GC_LVT), ('\u{c1a8}', '\u{c1a8}', GC_LV),
+        ('\u{c1a9}', '\u{c1c3}', GC_LVT), ('\u{c1c4}', '\u{c1c4}', GC_LV), ('\u{c1c5}', '\u{c1df}',
+        GC_LVT), ('\u{c1e0}', '\u{c1e0}', GC_LV), ('\u{c1e1}', '\u{c1fb}', GC_LVT), ('\u{c1fc}',
+        '\u{c1fc}', GC_LV), ('\u{c1fd}', '\u{c217}', GC_LVT), ('\u{c218}', '\u{c218}', GC_LV),
+        ('\u{c219}', '\u{c233}', GC_LVT), ('\u{c234}', '\u{c234}', GC_LV), ('\u{c235}', '\u{c24f}',
+        GC_LVT), ('\u{c250}', '\u{c250}', GC_LV), ('\u{c251}', '\u{c26b}', GC_LVT), ('\u{c26c}',
+        '\u{c26c}', GC_LV), ('\u{c26d}', '\u{c287}', GC_LVT), ('\u{c288}', '\u{c288}', GC_LV),
+        ('\u{c289}', '\u{c2a3}', GC_LVT), ('\u{c2a4}', '\u{c2a4}', GC_LV), ('\u{c2a5}', '\u{c2bf}',
+        GC_LVT), ('\u{c2c0}', '\u{c2c0}', GC_LV), ('\u{c2c1}', '\u{c2db}', GC_LVT), ('\u{c2dc}',
+        '\u{c2dc}', GC_LV), ('\u{c2dd}', '\u{c2f7}', GC_LVT), ('\u{c2f8}', '\u{c2f8}', GC_LV),
+        ('\u{c2f9}', '\u{c313}', GC_LVT), ('\u{c314}', '\u{c314}', GC_LV), ('\u{c315}', '\u{c32f}',
+        GC_LVT), ('\u{c330}', '\u{c330}', GC_LV), ('\u{c331}', '\u{c34b}', GC_LVT), ('\u{c34c}',
+        '\u{c34c}', GC_LV), ('\u{c34d}', '\u{c367}', GC_LVT), ('\u{c368}', '\u{c368}', GC_LV),
+        ('\u{c369}', '\u{c383}', GC_LVT), ('\u{c384}', '\u{c384}', GC_LV), ('\u{c385}', '\u{c39f}',
+        GC_LVT), ('\u{c3a0}', '\u{c3a0}', GC_LV), ('\u{c3a1}', '\u{c3bb}', GC_LVT), ('\u{c3bc}',
+        '\u{c3bc}', GC_LV), ('\u{c3bd}', '\u{c3d7}', GC_LVT), ('\u{c3d8}', '\u{c3d8}', GC_LV),
+        ('\u{c3d9}', '\u{c3f3}', GC_LVT), ('\u{c3f4}', '\u{c3f4}', GC_LV), ('\u{c3f5}', '\u{c40f}',
+        GC_LVT), ('\u{c410}', '\u{c410}', GC_LV), ('\u{c411}', '\u{c42b}', GC_LVT), ('\u{c42c}',
+        '\u{c42c}', GC_LV), ('\u{c42d}', '\u{c447}', GC_LVT), ('\u{c448}', '\u{c448}', GC_LV),
+        ('\u{c449}', '\u{c463}', GC_LVT), ('\u{c464}', '\u{c464}', GC_LV), ('\u{c465}', '\u{c47f}',
+        GC_LVT), ('\u{c480}', '\u{c480}', GC_LV), ('\u{c481}', '\u{c49b}', GC_LVT), ('\u{c49c}',
+        '\u{c49c}', GC_LV), ('\u{c49d}', '\u{c4b7}', GC_LVT), ('\u{c4b8}', '\u{c4b8}', GC_LV),
+        ('\u{c4b9}', '\u{c4d3}', GC_LVT), ('\u{c4d4}', '\u{c4d4}', GC_LV), ('\u{c4d5}', '\u{c4ef}',
+        GC_LVT), ('\u{c4f0}', '\u{c4f0}', GC_LV), ('\u{c4f1}', '\u{c50b}', GC_LVT), ('\u{c50c}',
+        '\u{c50c}', GC_LV), ('\u{c50d}', '\u{c527}', GC_LVT), ('\u{c528}', '\u{c528}', GC_LV),
+        ('\u{c529}', '\u{c543}', GC_LVT), ('\u{c544}', '\u{c544}', GC_LV), ('\u{c545}', '\u{c55f}',
+        GC_LVT), ('\u{c560}', '\u{c560}', GC_LV), ('\u{c561}', '\u{c57b}', GC_LVT), ('\u{c57c}',
+        '\u{c57c}', GC_LV), ('\u{c57d}', '\u{c597}', GC_LVT), ('\u{c598}', '\u{c598}', GC_LV),
+        ('\u{c599}', '\u{c5b3}', GC_LVT), ('\u{c5b4}', '\u{c5b4}', GC_LV), ('\u{c5b5}', '\u{c5cf}',
+        GC_LVT), ('\u{c5d0}', '\u{c5d0}', GC_LV), ('\u{c5d1}', '\u{c5eb}', GC_LVT), ('\u{c5ec}',
+        '\u{c5ec}', GC_LV), ('\u{c5ed}', '\u{c607}', GC_LVT), ('\u{c608}', '\u{c608}', GC_LV),
+        ('\u{c609}', '\u{c623}', GC_LVT), ('\u{c624}', '\u{c624}', GC_LV), ('\u{c625}', '\u{c63f}',
+        GC_LVT), ('\u{c640}', '\u{c640}', GC_LV), ('\u{c641}', '\u{c65b}', GC_LVT), ('\u{c65c}',
+        '\u{c65c}', GC_LV), ('\u{c65d}', '\u{c677}', GC_LVT), ('\u{c678}', '\u{c678}', GC_LV),
+        ('\u{c679}', '\u{c693}', GC_LVT), ('\u{c694}', '\u{c694}', GC_LV), ('\u{c695}', '\u{c6af}',
+        GC_LVT), ('\u{c6b0}', '\u{c6b0}', GC_LV), ('\u{c6b1}', '\u{c6cb}', GC_LVT), ('\u{c6cc}',
+        '\u{c6cc}', GC_LV), ('\u{c6cd}', '\u{c6e7}', GC_LVT), ('\u{c6e8}', '\u{c6e8}', GC_LV),
+        ('\u{c6e9}', '\u{c703}', GC_LVT), ('\u{c704}', '\u{c704}', GC_LV), ('\u{c705}', '\u{c71f}',
+        GC_LVT), ('\u{c720}', '\u{c720}', GC_LV), ('\u{c721}', '\u{c73b}', GC_LVT), ('\u{c73c}',
+        '\u{c73c}', GC_LV), ('\u{c73d}', '\u{c757}', GC_LVT), ('\u{c758}', '\u{c758}', GC_LV),
+        ('\u{c759}', '\u{c773}', GC_LVT), ('\u{c774}', '\u{c774}', GC_LV), ('\u{c775}', '\u{c78f}',
+        GC_LVT), ('\u{c790}', '\u{c790}', GC_LV), ('\u{c791}', '\u{c7ab}', GC_LVT), ('\u{c7ac}',
+        '\u{c7ac}', GC_LV), ('\u{c7ad}', '\u{c7c7}', GC_LVT), ('\u{c7c8}', '\u{c7c8}', GC_LV),
+        ('\u{c7c9}', '\u{c7e3}', GC_LVT), ('\u{c7e4}', '\u{c7e4}', GC_LV), ('\u{c7e5}', '\u{c7ff}',
+        GC_LVT), ('\u{c800}', '\u{c800}', GC_LV), ('\u{c801}', '\u{c81b}', GC_LVT), ('\u{c81c}',
+        '\u{c81c}', GC_LV), ('\u{c81d}', '\u{c837}', GC_LVT), ('\u{c838}', '\u{c838}', GC_LV),
+        ('\u{c839}', '\u{c853}', GC_LVT), ('\u{c854}', '\u{c854}', GC_LV), ('\u{c855}', '\u{c86f}',
+        GC_LVT), ('\u{c870}', '\u{c870}', GC_LV), ('\u{c871}', '\u{c88b}', GC_LVT), ('\u{c88c}',
+        '\u{c88c}', GC_LV), ('\u{c88d}', '\u{c8a7}', GC_LVT), ('\u{c8a8}', '\u{c8a8}', GC_LV),
+        ('\u{c8a9}', '\u{c8c3}', GC_LVT), ('\u{c8c4}', '\u{c8c4}', GC_LV), ('\u{c8c5}', '\u{c8df}',
+        GC_LVT), ('\u{c8e0}', '\u{c8e0}', GC_LV), ('\u{c8e1}', '\u{c8fb}', GC_LVT), ('\u{c8fc}',
+        '\u{c8fc}', GC_LV), ('\u{c8fd}', '\u{c917}', GC_LVT), ('\u{c918}', '\u{c918}', GC_LV),
+        ('\u{c919}', '\u{c933}', GC_LVT), ('\u{c934}', '\u{c934}', GC_LV), ('\u{c935}', '\u{c94f}',
+        GC_LVT), ('\u{c950}', '\u{c950}', GC_LV), ('\u{c951}', '\u{c96b}', GC_LVT), ('\u{c96c}',
+        '\u{c96c}', GC_LV), ('\u{c96d}', '\u{c987}', GC_LVT), ('\u{c988}', '\u{c988}', GC_LV),
+        ('\u{c989}', '\u{c9a3}', GC_LVT), ('\u{c9a4}', '\u{c9a4}', GC_LV), ('\u{c9a5}', '\u{c9bf}',
+        GC_LVT), ('\u{c9c0}', '\u{c9c0}', GC_LV), ('\u{c9c1}', '\u{c9db}', GC_LVT), ('\u{c9dc}',
+        '\u{c9dc}', GC_LV), ('\u{c9dd}', '\u{c9f7}', GC_LVT), ('\u{c9f8}', '\u{c9f8}', GC_LV),
+        ('\u{c9f9}', '\u{ca13}', GC_LVT), ('\u{ca14}', '\u{ca14}', GC_LV), ('\u{ca15}', '\u{ca2f}',
+        GC_LVT), ('\u{ca30}', '\u{ca30}', GC_LV), ('\u{ca31}', '\u{ca4b}', GC_LVT), ('\u{ca4c}',
+        '\u{ca4c}', GC_LV), ('\u{ca4d}', '\u{ca67}', GC_LVT), ('\u{ca68}', '\u{ca68}', GC_LV),
+        ('\u{ca69}', '\u{ca83}', GC_LVT), ('\u{ca84}', '\u{ca84}', GC_LV), ('\u{ca85}', '\u{ca9f}',
+        GC_LVT), ('\u{caa0}', '\u{caa0}', GC_LV), ('\u{caa1}', '\u{cabb}', GC_LVT), ('\u{cabc}',
+        '\u{cabc}', GC_LV), ('\u{cabd}', '\u{cad7}', GC_LVT), ('\u{cad8}', '\u{cad8}', GC_LV),
+        ('\u{cad9}', '\u{caf3}', GC_LVT), ('\u{caf4}', '\u{caf4}', GC_LV), ('\u{caf5}', '\u{cb0f}',
+        GC_LVT), ('\u{cb10}', '\u{cb10}', GC_LV), ('\u{cb11}', '\u{cb2b}', GC_LVT), ('\u{cb2c}',
+        '\u{cb2c}', GC_LV), ('\u{cb2d}', '\u{cb47}', GC_LVT), ('\u{cb48}', '\u{cb48}', GC_LV),
+        ('\u{cb49}', '\u{cb63}', GC_LVT), ('\u{cb64}', '\u{cb64}', GC_LV), ('\u{cb65}', '\u{cb7f}',
+        GC_LVT), ('\u{cb80}', '\u{cb80}', GC_LV), ('\u{cb81}', '\u{cb9b}', GC_LVT), ('\u{cb9c}',
+        '\u{cb9c}', GC_LV), ('\u{cb9d}', '\u{cbb7}', GC_LVT), ('\u{cbb8}', '\u{cbb8}', GC_LV),
+        ('\u{cbb9}', '\u{cbd3}', GC_LVT), ('\u{cbd4}', '\u{cbd4}', GC_LV), ('\u{cbd5}', '\u{cbef}',
+        GC_LVT), ('\u{cbf0}', '\u{cbf0}', GC_LV), ('\u{cbf1}', '\u{cc0b}', GC_LVT), ('\u{cc0c}',
+        '\u{cc0c}', GC_LV), ('\u{cc0d}', '\u{cc27}', GC_LVT), ('\u{cc28}', '\u{cc28}', GC_LV),
+        ('\u{cc29}', '\u{cc43}', GC_LVT), ('\u{cc44}', '\u{cc44}', GC_LV), ('\u{cc45}', '\u{cc5f}',
+        GC_LVT), ('\u{cc60}', '\u{cc60}', GC_LV), ('\u{cc61}', '\u{cc7b}', GC_LVT), ('\u{cc7c}',
+        '\u{cc7c}', GC_LV), ('\u{cc7d}', '\u{cc97}', GC_LVT), ('\u{cc98}', '\u{cc98}', GC_LV),
+        ('\u{cc99}', '\u{ccb3}', GC_LVT), ('\u{ccb4}', '\u{ccb4}', GC_LV), ('\u{ccb5}', '\u{cccf}',
+        GC_LVT), ('\u{ccd0}', '\u{ccd0}', GC_LV), ('\u{ccd1}', '\u{cceb}', GC_LVT), ('\u{ccec}',
+        '\u{ccec}', GC_LV), ('\u{cced}', '\u{cd07}', GC_LVT), ('\u{cd08}', '\u{cd08}', GC_LV),
+        ('\u{cd09}', '\u{cd23}', GC_LVT), ('\u{cd24}', '\u{cd24}', GC_LV), ('\u{cd25}', '\u{cd3f}',
+        GC_LVT), ('\u{cd40}', '\u{cd40}', GC_LV), ('\u{cd41}', '\u{cd5b}', GC_LVT), ('\u{cd5c}',
+        '\u{cd5c}', GC_LV), ('\u{cd5d}', '\u{cd77}', GC_LVT), ('\u{cd78}', '\u{cd78}', GC_LV),
+        ('\u{cd79}', '\u{cd93}', GC_LVT), ('\u{cd94}', '\u{cd94}', GC_LV), ('\u{cd95}', '\u{cdaf}',
+        GC_LVT), ('\u{cdb0}', '\u{cdb0}', GC_LV), ('\u{cdb1}', '\u{cdcb}', GC_LVT), ('\u{cdcc}',
+        '\u{cdcc}', GC_LV), ('\u{cdcd}', '\u{cde7}', GC_LVT), ('\u{cde8}', '\u{cde8}', GC_LV),
+        ('\u{cde9}', '\u{ce03}', GC_LVT), ('\u{ce04}', '\u{ce04}', GC_LV), ('\u{ce05}', '\u{ce1f}',
+        GC_LVT), ('\u{ce20}', '\u{ce20}', GC_LV), ('\u{ce21}', '\u{ce3b}', GC_LVT), ('\u{ce3c}',
+        '\u{ce3c}', GC_LV), ('\u{ce3d}', '\u{ce57}', GC_LVT), ('\u{ce58}', '\u{ce58}', GC_LV),
+        ('\u{ce59}', '\u{ce73}', GC_LVT), ('\u{ce74}', '\u{ce74}', GC_LV), ('\u{ce75}', '\u{ce8f}',
+        GC_LVT), ('\u{ce90}', '\u{ce90}', GC_LV), ('\u{ce91}', '\u{ceab}', GC_LVT), ('\u{ceac}',
+        '\u{ceac}', GC_LV), ('\u{cead}', '\u{cec7}', GC_LVT), ('\u{cec8}', '\u{cec8}', GC_LV),
+        ('\u{cec9}', '\u{cee3}', GC_LVT), ('\u{cee4}', '\u{cee4}', GC_LV), ('\u{cee5}', '\u{ceff}',
+        GC_LVT), ('\u{cf00}', '\u{cf00}', GC_LV), ('\u{cf01}', '\u{cf1b}', GC_LVT), ('\u{cf1c}',
+        '\u{cf1c}', GC_LV), ('\u{cf1d}', '\u{cf37}', GC_LVT), ('\u{cf38}', '\u{cf38}', GC_LV),
+        ('\u{cf39}', '\u{cf53}', GC_LVT), ('\u{cf54}', '\u{cf54}', GC_LV), ('\u{cf55}', '\u{cf6f}',
+        GC_LVT), ('\u{cf70}', '\u{cf70}', GC_LV), ('\u{cf71}', '\u{cf8b}', GC_LVT), ('\u{cf8c}',
+        '\u{cf8c}', GC_LV), ('\u{cf8d}', '\u{cfa7}', GC_LVT), ('\u{cfa8}', '\u{cfa8}', GC_LV),
+        ('\u{cfa9}', '\u{cfc3}', GC_LVT), ('\u{cfc4}', '\u{cfc4}', GC_LV), ('\u{cfc5}', '\u{cfdf}',
+        GC_LVT), ('\u{cfe0}', '\u{cfe0}', GC_LV), ('\u{cfe1}', '\u{cffb}', GC_LVT), ('\u{cffc}',
+        '\u{cffc}', GC_LV), ('\u{cffd}', '\u{d017}', GC_LVT), ('\u{d018}', '\u{d018}', GC_LV),
+        ('\u{d019}', '\u{d033}', GC_LVT), ('\u{d034}', '\u{d034}', GC_LV), ('\u{d035}', '\u{d04f}',
+        GC_LVT), ('\u{d050}', '\u{d050}', GC_LV), ('\u{d051}', '\u{d06b}', GC_LVT), ('\u{d06c}',
+        '\u{d06c}', GC_LV), ('\u{d06d}', '\u{d087}', GC_LVT), ('\u{d088}', '\u{d088}', GC_LV),
+        ('\u{d089}', '\u{d0a3}', GC_LVT), ('\u{d0a4}', '\u{d0a4}', GC_LV), ('\u{d0a5}', '\u{d0bf}',
+        GC_LVT), ('\u{d0c0}', '\u{d0c0}', GC_LV), ('\u{d0c1}', '\u{d0db}', GC_LVT), ('\u{d0dc}',
+        '\u{d0dc}', GC_LV), ('\u{d0dd}', '\u{d0f7}', GC_LVT), ('\u{d0f8}', '\u{d0f8}', GC_LV),
+        ('\u{d0f9}', '\u{d113}', GC_LVT), ('\u{d114}', '\u{d114}', GC_LV), ('\u{d115}', '\u{d12f}',
+        GC_LVT), ('\u{d130}', '\u{d130}', GC_LV), ('\u{d131}', '\u{d14b}', GC_LVT), ('\u{d14c}',
+        '\u{d14c}', GC_LV), ('\u{d14d}', '\u{d167}', GC_LVT), ('\u{d168}', '\u{d168}', GC_LV),
+        ('\u{d169}', '\u{d183}', GC_LVT), ('\u{d184}', '\u{d184}', GC_LV), ('\u{d185}', '\u{d19f}',
+        GC_LVT), ('\u{d1a0}', '\u{d1a0}', GC_LV), ('\u{d1a1}', '\u{d1bb}', GC_LVT), ('\u{d1bc}',
+        '\u{d1bc}', GC_LV), ('\u{d1bd}', '\u{d1d7}', GC_LVT), ('\u{d1d8}', '\u{d1d8}', GC_LV),
+        ('\u{d1d9}', '\u{d1f3}', GC_LVT), ('\u{d1f4}', '\u{d1f4}', GC_LV), ('\u{d1f5}', '\u{d20f}',
+        GC_LVT), ('\u{d210}', '\u{d210}', GC_LV), ('\u{d211}', '\u{d22b}', GC_LVT), ('\u{d22c}',
+        '\u{d22c}', GC_LV), ('\u{d22d}', '\u{d247}', GC_LVT), ('\u{d248}', '\u{d248}', GC_LV),
+        ('\u{d249}', '\u{d263}', GC_LVT), ('\u{d264}', '\u{d264}', GC_LV), ('\u{d265}', '\u{d27f}',
+        GC_LVT), ('\u{d280}', '\u{d280}', GC_LV), ('\u{d281}', '\u{d29b}', GC_LVT), ('\u{d29c}',
+        '\u{d29c}', GC_LV), ('\u{d29d}', '\u{d2b7}', GC_LVT), ('\u{d2b8}', '\u{d2b8}', GC_LV),
+        ('\u{d2b9}', '\u{d2d3}', GC_LVT), ('\u{d2d4}', '\u{d2d4}', GC_LV), ('\u{d2d5}', '\u{d2ef}',
+        GC_LVT), ('\u{d2f0}', '\u{d2f0}', GC_LV), ('\u{d2f1}', '\u{d30b}', GC_LVT), ('\u{d30c}',
+        '\u{d30c}', GC_LV), ('\u{d30d}', '\u{d327}', GC_LVT), ('\u{d328}', '\u{d328}', GC_LV),
+        ('\u{d329}', '\u{d343}', GC_LVT), ('\u{d344}', '\u{d344}', GC_LV), ('\u{d345}', '\u{d35f}',
+        GC_LVT), ('\u{d360}', '\u{d360}', GC_LV), ('\u{d361}', '\u{d37b}', GC_LVT), ('\u{d37c}',
+        '\u{d37c}', GC_LV), ('\u{d37d}', '\u{d397}', GC_LVT), ('\u{d398}', '\u{d398}', GC_LV),
+        ('\u{d399}', '\u{d3b3}', GC_LVT), ('\u{d3b4}', '\u{d3b4}', GC_LV), ('\u{d3b5}', '\u{d3cf}',
+        GC_LVT), ('\u{d3d0}', '\u{d3d0}', GC_LV), ('\u{d3d1}', '\u{d3eb}', GC_LVT), ('\u{d3ec}',
+        '\u{d3ec}', GC_LV), ('\u{d3ed}', '\u{d407}', GC_LVT), ('\u{d408}', '\u{d408}', GC_LV),
+        ('\u{d409}', '\u{d423}', GC_LVT), ('\u{d424}', '\u{d424}', GC_LV), ('\u{d425}', '\u{d43f}',
+        GC_LVT), ('\u{d440}', '\u{d440}', GC_LV), ('\u{d441}', '\u{d45b}', GC_LVT), ('\u{d45c}',
+        '\u{d45c}', GC_LV), ('\u{d45d}', '\u{d477}', GC_LVT), ('\u{d478}', '\u{d478}', GC_LV),
+        ('\u{d479}', '\u{d493}', GC_LVT), ('\u{d494}', '\u{d494}', GC_LV), ('\u{d495}', '\u{d4af}',
+        GC_LVT), ('\u{d4b0}', '\u{d4b0}', GC_LV), ('\u{d4b1}', '\u{d4cb}', GC_LVT), ('\u{d4cc}',
+        '\u{d4cc}', GC_LV), ('\u{d4cd}', '\u{d4e7}', GC_LVT), ('\u{d4e8}', '\u{d4e8}', GC_LV),
+        ('\u{d4e9}', '\u{d503}', GC_LVT), ('\u{d504}', '\u{d504}', GC_LV), ('\u{d505}', '\u{d51f}',
+        GC_LVT), ('\u{d520}', '\u{d520}', GC_LV), ('\u{d521}', '\u{d53b}', GC_LVT), ('\u{d53c}',
+        '\u{d53c}', GC_LV), ('\u{d53d}', '\u{d557}', GC_LVT), ('\u{d558}', '\u{d558}', GC_LV),
+        ('\u{d559}', '\u{d573}', GC_LVT), ('\u{d574}', '\u{d574}', GC_LV), ('\u{d575}', '\u{d58f}',
+        GC_LVT), ('\u{d590}', '\u{d590}', GC_LV), ('\u{d591}', '\u{d5ab}', GC_LVT), ('\u{d5ac}',
+        '\u{d5ac}', GC_LV), ('\u{d5ad}', '\u{d5c7}', GC_LVT), ('\u{d5c8}', '\u{d5c8}', GC_LV),
+        ('\u{d5c9}', '\u{d5e3}', GC_LVT), ('\u{d5e4}', '\u{d5e4}', GC_LV), ('\u{d5e5}', '\u{d5ff}',
+        GC_LVT), ('\u{d600}', '\u{d600}', GC_LV), ('\u{d601}', '\u{d61b}', GC_LVT), ('\u{d61c}',
+        '\u{d61c}', GC_LV), ('\u{d61d}', '\u{d637}', GC_LVT), ('\u{d638}', '\u{d638}', GC_LV),
+        ('\u{d639}', '\u{d653}', GC_LVT), ('\u{d654}', '\u{d654}', GC_LV), ('\u{d655}', '\u{d66f}',
+        GC_LVT), ('\u{d670}', '\u{d670}', GC_LV), ('\u{d671}', '\u{d68b}', GC_LVT), ('\u{d68c}',
+        '\u{d68c}', GC_LV), ('\u{d68d}', '\u{d6a7}', GC_LVT), ('\u{d6a8}', '\u{d6a8}', GC_LV),
+        ('\u{d6a9}', '\u{d6c3}', GC_LVT), ('\u{d6c4}', '\u{d6c4}', GC_LV), ('\u{d6c5}', '\u{d6df}',
+        GC_LVT), ('\u{d6e0}', '\u{d6e0}', GC_LV), ('\u{d6e1}', '\u{d6fb}', GC_LVT), ('\u{d6fc}',
+        '\u{d6fc}', GC_LV), ('\u{d6fd}', '\u{d717}', GC_LVT), ('\u{d718}', '\u{d718}', GC_LV),
+        ('\u{d719}', '\u{d733}', GC_LVT), ('\u{d734}', '\u{d734}', GC_LV), ('\u{d735}', '\u{d74f}',
+        GC_LVT), ('\u{d750}', '\u{d750}', GC_LV), ('\u{d751}', '\u{d76b}', GC_LVT), ('\u{d76c}',
+        '\u{d76c}', GC_LV), ('\u{d76d}', '\u{d787}', GC_LVT), ('\u{d788}', '\u{d788}', GC_LV),
+        ('\u{d789}', '\u{d7a3}', GC_LVT), ('\u{d7b0}', '\u{d7c6}', GC_V), ('\u{d7cb}', '\u{d7fb}',
+        GC_T), ('\u{fb1e}', '\u{fb1e}', GC_Extend), ('\u{fe00}', '\u{fe0f}', GC_Extend),
+        ('\u{fe20}', '\u{fe2f}', GC_Extend), ('\u{feff}', '\u{feff}', GC_Control), ('\u{ff9e}',
+        '\u{ff9f}', GC_Extend), ('\u{fff0}', '\u{fffb}', GC_Control), ('\u{101fd}', '\u{101fd}',
+        GC_Extend), ('\u{102e0}', '\u{102e0}', GC_Extend), ('\u{10376}', '\u{1037a}', GC_Extend),
+        ('\u{10a01}', '\u{10a03}', GC_Extend), ('\u{10a05}', '\u{10a06}', GC_Extend), ('\u{10a0c}',
+        '\u{10a0f}', GC_Extend), ('\u{10a38}', '\u{10a3a}', GC_Extend), ('\u{10a3f}', '\u{10a3f}',
+        GC_Extend), ('\u{10ae5}', '\u{10ae6}', GC_Extend), ('\u{11000}', '\u{11000}',
+        GC_SpacingMark), ('\u{11001}', '\u{11001}', GC_Extend), ('\u{11002}', '\u{11002}',
+        GC_SpacingMark), ('\u{11038}', '\u{11046}', GC_Extend), ('\u{1107f}', '\u{11081}',
+        GC_Extend), ('\u{11082}', '\u{11082}', GC_SpacingMark), ('\u{110b0}', '\u{110b2}',
+        GC_SpacingMark), ('\u{110b3}', '\u{110b6}', GC_Extend), ('\u{110b7}', '\u{110b8}',
+        GC_SpacingMark), ('\u{110b9}', '\u{110ba}', GC_Extend), ('\u{110bd}', '\u{110bd}',
+        GC_Prepend), ('\u{11100}', '\u{11102}', GC_Extend), ('\u{11127}', '\u{1112b}', GC_Extend),
+        ('\u{1112c}', '\u{1112c}', GC_SpacingMark), ('\u{1112d}', '\u{11134}', GC_Extend),
+        ('\u{11173}', '\u{11173}', GC_Extend), ('\u{11180}', '\u{11181}', GC_Extend), ('\u{11182}',
+        '\u{11182}', GC_SpacingMark), ('\u{111b3}', '\u{111b5}', GC_SpacingMark), ('\u{111b6}',
+        '\u{111be}', GC_Extend), ('\u{111bf}', '\u{111c0}', GC_SpacingMark), ('\u{111c2}',
+        '\u{111c3}', GC_Prepend), ('\u{111ca}', '\u{111cc}', GC_Extend), ('\u{1122c}', '\u{1122e}',
+        GC_SpacingMark), ('\u{1122f}', '\u{11231}', GC_Extend), ('\u{11232}', '\u{11233}',
+        GC_SpacingMark), ('\u{11234}', '\u{11234}', GC_Extend), ('\u{11235}', '\u{11235}',
+        GC_SpacingMark), ('\u{11236}', '\u{11237}', GC_Extend), ('\u{1123e}', '\u{1123e}',
+        GC_Extend), ('\u{112df}', '\u{112df}', GC_Extend), ('\u{112e0}', '\u{112e2}',
+        GC_SpacingMark), ('\u{112e3}', '\u{112ea}', GC_Extend), ('\u{11300}', '\u{11301}',
+        GC_Extend), ('\u{11302}', '\u{11303}', GC_SpacingMark), ('\u{1133c}', '\u{1133c}',
+        GC_Extend), ('\u{1133e}', '\u{1133e}', GC_Extend), ('\u{1133f}', '\u{1133f}',
+        GC_SpacingMark), ('\u{11340}', '\u{11340}', GC_Extend), ('\u{11341}', '\u{11344}',
+        GC_SpacingMark), ('\u{11347}', '\u{11348}', GC_SpacingMark), ('\u{1134b}', '\u{1134d}',
+        GC_SpacingMark), ('\u{11357}', '\u{11357}', GC_Extend), ('\u{11362}', '\u{11363}',
+        GC_SpacingMark), ('\u{11366}', '\u{1136c}', GC_Extend), ('\u{11370}', '\u{11374}',
+        GC_Extend), ('\u{11435}', '\u{11437}', GC_SpacingMark), ('\u{11438}', '\u{1143f}',
+        GC_Extend), ('\u{11440}', '\u{11441}', GC_SpacingMark), ('\u{11442}', '\u{11444}',
+        GC_Extend), ('\u{11445}', '\u{11445}', GC_SpacingMark), ('\u{11446}', '\u{11446}',
+        GC_Extend), ('\u{114b0}', '\u{114b0}', GC_Extend), ('\u{114b1}', '\u{114b2}',
+        GC_SpacingMark), ('\u{114b3}', '\u{114b8}', GC_Extend), ('\u{114b9}', '\u{114b9}',
+        GC_SpacingMark), ('\u{114ba}', '\u{114ba}', GC_Extend), ('\u{114bb}', '\u{114bc}',
+        GC_SpacingMark), ('\u{114bd}', '\u{114bd}', GC_Extend), ('\u{114be}', '\u{114be}',
+        GC_SpacingMark), ('\u{114bf}', '\u{114c0}', GC_Extend), ('\u{114c1}', '\u{114c1}',
+        GC_SpacingMark), ('\u{114c2}', '\u{114c3}', GC_Extend), ('\u{115af}', '\u{115af}',
+        GC_Extend), ('\u{115b0}', '\u{115b1}', GC_SpacingMark), ('\u{115b2}', '\u{115b5}',
+        GC_Extend), ('\u{115b8}', '\u{115bb}', GC_SpacingMark), ('\u{115bc}', '\u{115bd}',
+        GC_Extend), ('\u{115be}', '\u{115be}', GC_SpacingMark), ('\u{115bf}', '\u{115c0}',
+        GC_Extend), ('\u{115dc}', '\u{115dd}', GC_Extend), ('\u{11630}', '\u{11632}',
+        GC_SpacingMark), ('\u{11633}', '\u{1163a}', GC_Extend), ('\u{1163b}', '\u{1163c}',
+        GC_SpacingMark), ('\u{1163d}', '\u{1163d}', GC_Extend), ('\u{1163e}', '\u{1163e}',
+        GC_SpacingMark), ('\u{1163f}', '\u{11640}', GC_Extend), ('\u{116ab}', '\u{116ab}',
+        GC_Extend), ('\u{116ac}', '\u{116ac}', GC_SpacingMark), ('\u{116ad}', '\u{116ad}',
+        GC_Extend), ('\u{116ae}', '\u{116af}', GC_SpacingMark), ('\u{116b0}', '\u{116b5}',
+        GC_Extend), ('\u{116b6}', '\u{116b6}', GC_SpacingMark), ('\u{116b7}', '\u{116b7}',
+        GC_Extend), ('\u{1171d}', '\u{1171f}', GC_Extend), ('\u{11720}', '\u{11721}',
+        GC_SpacingMark), ('\u{11722}', '\u{11725}', GC_Extend), ('\u{11726}', '\u{11726}',
+        GC_SpacingMark), ('\u{11727}', '\u{1172b}', GC_Extend), ('\u{11c2f}', '\u{11c2f}',
+        GC_SpacingMark), ('\u{11c30}', '\u{11c36}', GC_Extend), ('\u{11c38}', '\u{11c3d}',
+        GC_Extend), ('\u{11c3e}', '\u{11c3e}', GC_SpacingMark), ('\u{11c3f}', '\u{11c3f}',
+        GC_Extend), ('\u{11c92}', '\u{11ca7}', GC_Extend), ('\u{11ca9}', '\u{11ca9}',
+        GC_SpacingMark), ('\u{11caa}', '\u{11cb0}', GC_Extend), ('\u{11cb1}', '\u{11cb1}',
+        GC_SpacingMark), ('\u{11cb2}', '\u{11cb3}', GC_Extend), ('\u{11cb4}', '\u{11cb4}',
+        GC_SpacingMark), ('\u{11cb5}', '\u{11cb6}', GC_Extend), ('\u{16af0}', '\u{16af4}',
+        GC_Extend), ('\u{16b30}', '\u{16b36}', GC_Extend), ('\u{16f51}', '\u{16f7e}',
+        GC_SpacingMark), ('\u{16f8f}', '\u{16f92}', GC_Extend), ('\u{1bc9d}', '\u{1bc9e}',
+        GC_Extend), ('\u{1bca0}', '\u{1bca3}', GC_Control), ('\u{1d165}', '\u{1d165}', GC_Extend),
+        ('\u{1d166}', '\u{1d166}', GC_SpacingMark), ('\u{1d167}', '\u{1d169}', GC_Extend),
+        ('\u{1d16d}', '\u{1d16d}', GC_SpacingMark), ('\u{1d16e}', '\u{1d172}', GC_Extend),
+        ('\u{1d173}', '\u{1d17a}', GC_Control), ('\u{1d17b}', '\u{1d182}', GC_Extend), ('\u{1d185}',
+        '\u{1d18b}', GC_Extend), ('\u{1d1aa}', '\u{1d1ad}', GC_Extend), ('\u{1d242}', '\u{1d244}',
+        GC_Extend), ('\u{1da00}', '\u{1da36}', GC_Extend), ('\u{1da3b}', '\u{1da6c}', GC_Extend),
+        ('\u{1da75}', '\u{1da75}', GC_Extend), ('\u{1da84}', '\u{1da84}', GC_Extend), ('\u{1da9b}',
+        '\u{1da9f}', GC_Extend), ('\u{1daa1}', '\u{1daaf}', GC_Extend), ('\u{1e000}', '\u{1e006}',
+        GC_Extend), ('\u{1e008}', '\u{1e018}', GC_Extend), ('\u{1e01b}', '\u{1e021}', GC_Extend),
+        ('\u{1e023}', '\u{1e024}', GC_Extend), ('\u{1e026}', '\u{1e02a}', GC_Extend), ('\u{1e8d0}',
+        '\u{1e8d6}', GC_Extend), ('\u{1e944}', '\u{1e94a}', GC_Extend), ('\u{1f1e6}', '\u{1f1ff}',
+        GC_Regional_Indicator), ('\u{1f385}', '\u{1f385}', GC_E_Base), ('\u{1f3c3}', '\u{1f3c4}',
+        GC_E_Base), ('\u{1f3ca}', '\u{1f3cb}', GC_E_Base), ('\u{1f3fb}', '\u{1f3ff}',
+        GC_E_Modifier), ('\u{1f442}', '\u{1f443}', GC_E_Base), ('\u{1f446}', '\u{1f450}',
+        GC_E_Base), ('\u{1f466}', '\u{1f469}', GC_E_Base_GAZ), ('\u{1f46e}', '\u{1f46e}',
+        GC_E_Base), ('\u{1f470}', '\u{1f478}', GC_E_Base), ('\u{1f47c}', '\u{1f47c}', GC_E_Base),
+        ('\u{1f481}', '\u{1f483}', GC_E_Base), ('\u{1f485}', '\u{1f487}', GC_E_Base), ('\u{1f48b}',
+        '\u{1f48b}', GC_Glue_After_Zwj), ('\u{1f4aa}', '\u{1f4aa}', GC_E_Base), ('\u{1f575}',
+        '\u{1f575}', GC_E_Base), ('\u{1f57a}', '\u{1f57a}', GC_E_Base), ('\u{1f590}', '\u{1f590}',
+        GC_E_Base), ('\u{1f595}', '\u{1f596}', GC_E_Base), ('\u{1f5e8}', '\u{1f5e8}',
+        GC_Glue_After_Zwj), ('\u{1f645}', '\u{1f647}', GC_E_Base), ('\u{1f64b}', '\u{1f64f}',
+        GC_E_Base), ('\u{1f6a3}', '\u{1f6a3}', GC_E_Base), ('\u{1f6b4}', '\u{1f6b6}', GC_E_Base),
+        ('\u{1f6c0}', '\u{1f6c0}', GC_E_Base), ('\u{1f918}', '\u{1f91e}', GC_E_Base), ('\u{1f926}',
+        '\u{1f926}', GC_E_Base), ('\u{1f930}', '\u{1f930}', GC_E_Base), ('\u{1f933}', '\u{1f939}',
+        GC_E_Base), ('\u{1f93c}', '\u{1f93e}', GC_E_Base), ('\u{e0000}', '\u{e001f}', GC_Control),
+        ('\u{e0020}', '\u{e007f}', GC_Extend), ('\u{e0080}', '\u{e00ff}', GC_Control), ('\u{e0100}',
+        '\u{e01ef}', GC_Extend), ('\u{e01f0}', '\u{e0fff}', GC_Control)
+    ];
+
+}
+
+pub mod word {
+    use core::result::Result::{Ok, Err};
+
+    pub use self::WordCat::*;
+
+    #[allow(non_camel_case_types)]
+    #[derive(Clone, Copy, PartialEq, Eq)]
+    pub enum WordCat {
+        WC_ALetter,
+        WC_Any,
+        WC_CR,
+        WC_Double_Quote,
+        WC_E_Base,
+        WC_E_Base_GAZ,
+        WC_E_Modifier,
+        WC_Extend,
+        WC_ExtendNumLet,
+        WC_Format,
+        WC_Glue_After_Zwj,
+        WC_Hebrew_Letter,
+        WC_Katakana,
+        WC_LF,
+        WC_MidLetter,
+        WC_MidNum,
+        WC_MidNumLet,
+        WC_Newline,
+        WC_Numeric,
+        WC_Regional_Indicator,
+        WC_Single_Quote,
+        WC_ZWJ,
+    }
+
+    fn bsearch_range_value_table(c: char, r: &'static [(char, char, WordCat)]) -> WordCat {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        match r.binary_search_by(|&(lo, hi, _)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }) {
+            Ok(idx) => {
+                let (_, _, cat) = r[idx];
+                cat
+            }
+            Err(_) => WC_Any
+        }
+    }
+
+    pub fn word_category(c: char) -> WordCat {
+        bsearch_range_value_table(c, word_cat_table)
+    }
+
+    const word_cat_table: &'static [(char, char, WordCat)] = &[
+        ('\u{a}', '\u{a}', WC_LF), ('\u{b}', '\u{c}', WC_Newline), ('\u{d}', '\u{d}', WC_CR),
+        ('\u{22}', '\u{22}', WC_Double_Quote), ('\u{27}', '\u{27}', WC_Single_Quote), ('\u{2c}',
+        '\u{2c}', WC_MidNum), ('\u{2e}', '\u{2e}', WC_MidNumLet), ('\u{30}', '\u{39}', WC_Numeric),
+        ('\u{3a}', '\u{3a}', WC_MidLetter), ('\u{3b}', '\u{3b}', WC_MidNum), ('\u{41}', '\u{5a}',
+        WC_ALetter), ('\u{5f}', '\u{5f}', WC_ExtendNumLet), ('\u{61}', '\u{7a}', WC_ALetter),
+        ('\u{85}', '\u{85}', WC_Newline), ('\u{aa}', '\u{aa}', WC_ALetter), ('\u{ad}', '\u{ad}',
+        WC_Format), ('\u{b5}', '\u{b5}', WC_ALetter), ('\u{b7}', '\u{b7}', WC_MidLetter), ('\u{ba}',
+        '\u{ba}', WC_ALetter), ('\u{c0}', '\u{d6}', WC_ALetter), ('\u{d8}', '\u{f6}', WC_ALetter),
+        ('\u{f8}', '\u{2c1}', WC_ALetter), ('\u{2c6}', '\u{2d1}', WC_ALetter), ('\u{2d7}',
+        '\u{2d7}', WC_MidLetter), ('\u{2e0}', '\u{2e4}', WC_ALetter), ('\u{2ec}', '\u{2ec}',
+        WC_ALetter), ('\u{2ee}', '\u{2ee}', WC_ALetter), ('\u{300}', '\u{36f}', WC_Extend),
+        ('\u{370}', '\u{374}', WC_ALetter), ('\u{376}', '\u{377}', WC_ALetter), ('\u{37a}',
+        '\u{37d}', WC_ALetter), ('\u{37e}', '\u{37e}', WC_MidNum), ('\u{37f}', '\u{37f}',
+        WC_ALetter), ('\u{386}', '\u{386}', WC_ALetter), ('\u{387}', '\u{387}', WC_MidLetter),
+        ('\u{388}', '\u{38a}', WC_ALetter), ('\u{38c}', '\u{38c}', WC_ALetter), ('\u{38e}',
+        '\u{3a1}', WC_ALetter), ('\u{3a3}', '\u{3f5}', WC_ALetter), ('\u{3f7}', '\u{481}',
+        WC_ALetter), ('\u{483}', '\u{489}', WC_Extend), ('\u{48a}', '\u{52f}', WC_ALetter),
+        ('\u{531}', '\u{556}', WC_ALetter), ('\u{559}', '\u{559}', WC_ALetter), ('\u{561}',
+        '\u{587}', WC_ALetter), ('\u{589}', '\u{589}', WC_MidNum), ('\u{591}', '\u{5bd}',
+        WC_Extend), ('\u{5bf}', '\u{5bf}', WC_Extend), ('\u{5c1}', '\u{5c2}', WC_Extend),
+        ('\u{5c4}', '\u{5c5}', WC_Extend), ('\u{5c7}', '\u{5c7}', WC_Extend), ('\u{5d0}', '\u{5ea}',
+        WC_Hebrew_Letter), ('\u{5f0}', '\u{5f2}', WC_Hebrew_Letter), ('\u{5f3}', '\u{5f3}',
+        WC_ALetter), ('\u{5f4}', '\u{5f4}', WC_MidLetter), ('\u{600}', '\u{605}', WC_Format),
+        ('\u{60c}', '\u{60d}', WC_MidNum), ('\u{610}', '\u{61a}', WC_Extend), ('\u{61c}', '\u{61c}',
+        WC_Format), ('\u{620}', '\u{64a}', WC_ALetter), ('\u{64b}', '\u{65f}', WC_Extend),
+        ('\u{660}', '\u{669}', WC_Numeric), ('\u{66b}', '\u{66b}', WC_Numeric), ('\u{66c}',
+        '\u{66c}', WC_MidNum), ('\u{66e}', '\u{66f}', WC_ALetter), ('\u{670}', '\u{670}',
+        WC_Extend), ('\u{671}', '\u{6d3}', WC_ALetter), ('\u{6d5}', '\u{6d5}', WC_ALetter),
+        ('\u{6d6}', '\u{6dc}', WC_Extend), ('\u{6dd}', '\u{6dd}', WC_Format), ('\u{6df}', '\u{6e4}',
+        WC_Extend), ('\u{6e5}', '\u{6e6}', WC_ALetter), ('\u{6e7}', '\u{6e8}', WC_Extend),
+        ('\u{6ea}', '\u{6ed}', WC_Extend), ('\u{6ee}', '\u{6ef}', WC_ALetter), ('\u{6f0}',
+        '\u{6f9}', WC_Numeric), ('\u{6fa}', '\u{6fc}', WC_ALetter), ('\u{6ff}', '\u{6ff}',
+        WC_ALetter), ('\u{70f}', '\u{70f}', WC_Format), ('\u{710}', '\u{710}', WC_ALetter),
+        ('\u{711}', '\u{711}', WC_Extend), ('\u{712}', '\u{72f}', WC_ALetter), ('\u{730}',
+        '\u{74a}', WC_Extend), ('\u{74d}', '\u{7a5}', WC_ALetter), ('\u{7a6}', '\u{7b0}',
+        WC_Extend), ('\u{7b1}', '\u{7b1}', WC_ALetter), ('\u{7c0}', '\u{7c9}', WC_Numeric),
+        ('\u{7ca}', '\u{7ea}', WC_ALetter), ('\u{7eb}', '\u{7f3}', WC_Extend), ('\u{7f4}',
+        '\u{7f5}', WC_ALetter), ('\u{7f8}', '\u{7f8}', WC_MidNum), ('\u{7fa}', '\u{7fa}',
+        WC_ALetter), ('\u{800}', '\u{815}', WC_ALetter), ('\u{816}', '\u{819}', WC_Extend),
+        ('\u{81a}', '\u{81a}', WC_ALetter), ('\u{81b}', '\u{823}', WC_Extend), ('\u{824}',
+        '\u{824}', WC_ALetter), ('\u{825}', '\u{827}', WC_Extend), ('\u{828}', '\u{828}',
+        WC_ALetter), ('\u{829}', '\u{82d}', WC_Extend), ('\u{840}', '\u{858}', WC_ALetter),
+        ('\u{859}', '\u{85b}', WC_Extend), ('\u{8a0}', '\u{8b4}', WC_ALetter), ('\u{8b6}',
+        '\u{8bd}', WC_ALetter), ('\u{8d4}', '\u{8e1}', WC_Extend), ('\u{8e2}', '\u{8e2}',
+        WC_Format), ('\u{8e3}', '\u{903}', WC_Extend), ('\u{904}', '\u{939}', WC_ALetter),
+        ('\u{93a}', '\u{93c}', WC_Extend), ('\u{93d}', '\u{93d}', WC_ALetter), ('\u{93e}',
+        '\u{94f}', WC_Extend), ('\u{950}', '\u{950}', WC_ALetter), ('\u{951}', '\u{957}',
+        WC_Extend), ('\u{958}', '\u{961}', WC_ALetter), ('\u{962}', '\u{963}', WC_Extend),
+        ('\u{966}', '\u{96f}', WC_Numeric), ('\u{971}', '\u{980}', WC_ALetter), ('\u{981}',
+        '\u{983}', WC_Extend), ('\u{985}', '\u{98c}', WC_ALetter), ('\u{98f}', '\u{990}',
+        WC_ALetter), ('\u{993}', '\u{9a8}', WC_ALetter), ('\u{9aa}', '\u{9b0}', WC_ALetter),
+        ('\u{9b2}', '\u{9b2}', WC_ALetter), ('\u{9b6}', '\u{9b9}', WC_ALetter), ('\u{9bc}',
+        '\u{9bc}', WC_Extend), ('\u{9bd}', '\u{9bd}', WC_ALetter), ('\u{9be}', '\u{9c4}',
+        WC_Extend), ('\u{9c7}', '\u{9c8}', WC_Extend), ('\u{9cb}', '\u{9cd}', WC_Extend),
+        ('\u{9ce}', '\u{9ce}', WC_ALetter), ('\u{9d7}', '\u{9d7}', WC_Extend), ('\u{9dc}',
+        '\u{9dd}', WC_ALetter), ('\u{9df}', '\u{9e1}', WC_ALetter), ('\u{9e2}', '\u{9e3}',
+        WC_Extend), ('\u{9e6}', '\u{9ef}', WC_Numeric), ('\u{9f0}', '\u{9f1}', WC_ALetter),
+        ('\u{a01}', '\u{a03}', WC_Extend), ('\u{a05}', '\u{a0a}', WC_ALetter), ('\u{a0f}',
+        '\u{a10}', WC_ALetter), ('\u{a13}', '\u{a28}', WC_ALetter), ('\u{a2a}', '\u{a30}',
+        WC_ALetter), ('\u{a32}', '\u{a33}', WC_ALetter), ('\u{a35}', '\u{a36}', WC_ALetter),
+        ('\u{a38}', '\u{a39}', WC_ALetter), ('\u{a3c}', '\u{a3c}', WC_Extend), ('\u{a3e}',
+        '\u{a42}', WC_Extend), ('\u{a47}', '\u{a48}', WC_Extend), ('\u{a4b}', '\u{a4d}', WC_Extend),
+        ('\u{a51}', '\u{a51}', WC_Extend), ('\u{a59}', '\u{a5c}', WC_ALetter), ('\u{a5e}',
+        '\u{a5e}', WC_ALetter), ('\u{a66}', '\u{a6f}', WC_Numeric), ('\u{a70}', '\u{a71}',
+        WC_Extend), ('\u{a72}', '\u{a74}', WC_ALetter), ('\u{a75}', '\u{a75}', WC_Extend),
+        ('\u{a81}', '\u{a83}', WC_Extend), ('\u{a85}', '\u{a8d}', WC_ALetter), ('\u{a8f}',
+        '\u{a91}', WC_ALetter), ('\u{a93}', '\u{aa8}', WC_ALetter), ('\u{aaa}', '\u{ab0}',
+        WC_ALetter), ('\u{ab2}', '\u{ab3}', WC_ALetter), ('\u{ab5}', '\u{ab9}', WC_ALetter),
+        ('\u{abc}', '\u{abc}', WC_Extend), ('\u{abd}', '\u{abd}', WC_ALetter), ('\u{abe}',
+        '\u{ac5}', WC_Extend), ('\u{ac7}', '\u{ac9}', WC_Extend), ('\u{acb}', '\u{acd}', WC_Extend),
+        ('\u{ad0}', '\u{ad0}', WC_ALetter), ('\u{ae0}', '\u{ae1}', WC_ALetter), ('\u{ae2}',
+        '\u{ae3}', WC_Extend), ('\u{ae6}', '\u{aef}', WC_Numeric), ('\u{af9}', '\u{af9}',
+        WC_ALetter), ('\u{b01}', '\u{b03}', WC_Extend), ('\u{b05}', '\u{b0c}', WC_ALetter),
+        ('\u{b0f}', '\u{b10}', WC_ALetter), ('\u{b13}', '\u{b28}', WC_ALetter), ('\u{b2a}',
+        '\u{b30}', WC_ALetter), ('\u{b32}', '\u{b33}', WC_ALetter), ('\u{b35}', '\u{b39}',
+        WC_ALetter), ('\u{b3c}', '\u{b3c}', WC_Extend), ('\u{b3d}', '\u{b3d}', WC_ALetter),
+        ('\u{b3e}', '\u{b44}', WC_Extend), ('\u{b47}', '\u{b48}', WC_Extend), ('\u{b4b}', '\u{b4d}',
+        WC_Extend), ('\u{b56}', '\u{b57}', WC_Extend), ('\u{b5c}', '\u{b5d}', WC_ALetter),
+        ('\u{b5f}', '\u{b61}', WC_ALetter), ('\u{b62}', '\u{b63}', WC_Extend), ('\u{b66}',
+        '\u{b6f}', WC_Numeric), ('\u{b71}', '\u{b71}', WC_ALetter), ('\u{b82}', '\u{b82}',
+        WC_Extend), ('\u{b83}', '\u{b83}', WC_ALetter), ('\u{b85}', '\u{b8a}', WC_ALetter),
+        ('\u{b8e}', '\u{b90}', WC_ALetter), ('\u{b92}', '\u{b95}', WC_ALetter), ('\u{b99}',
+        '\u{b9a}', WC_ALetter), ('\u{b9c}', '\u{b9c}', WC_ALetter), ('\u{b9e}', '\u{b9f}',
+        WC_ALetter), ('\u{ba3}', '\u{ba4}', WC_ALetter), ('\u{ba8}', '\u{baa}', WC_ALetter),
+        ('\u{bae}', '\u{bb9}', WC_ALetter), ('\u{bbe}', '\u{bc2}', WC_Extend), ('\u{bc6}',
+        '\u{bc8}', WC_Extend), ('\u{bca}', '\u{bcd}', WC_Extend), ('\u{bd0}', '\u{bd0}',
+        WC_ALetter), ('\u{bd7}', '\u{bd7}', WC_Extend), ('\u{be6}', '\u{bef}', WC_Numeric),
+        ('\u{c00}', '\u{c03}', WC_Extend), ('\u{c05}', '\u{c0c}', WC_ALetter), ('\u{c0e}',
+        '\u{c10}', WC_ALetter), ('\u{c12}', '\u{c28}', WC_ALetter), ('\u{c2a}', '\u{c39}',
+        WC_ALetter), ('\u{c3d}', '\u{c3d}', WC_ALetter), ('\u{c3e}', '\u{c44}', WC_Extend),
+        ('\u{c46}', '\u{c48}', WC_Extend), ('\u{c4a}', '\u{c4d}', WC_Extend), ('\u{c55}', '\u{c56}',
+        WC_Extend), ('\u{c58}', '\u{c5a}', WC_ALetter), ('\u{c60}', '\u{c61}', WC_ALetter),
+        ('\u{c62}', '\u{c63}', WC_Extend), ('\u{c66}', '\u{c6f}', WC_Numeric), ('\u{c80}',
+        '\u{c80}', WC_ALetter), ('\u{c81}', '\u{c83}', WC_Extend), ('\u{c85}', '\u{c8c}',
+        WC_ALetter), ('\u{c8e}', '\u{c90}', WC_ALetter), ('\u{c92}', '\u{ca8}', WC_ALetter),
+        ('\u{caa}', '\u{cb3}', WC_ALetter), ('\u{cb5}', '\u{cb9}', WC_ALetter), ('\u{cbc}',
+        '\u{cbc}', WC_Extend), ('\u{cbd}', '\u{cbd}', WC_ALetter), ('\u{cbe}', '\u{cc4}',
+        WC_Extend), ('\u{cc6}', '\u{cc8}', WC_Extend), ('\u{cca}', '\u{ccd}', WC_Extend),
+        ('\u{cd5}', '\u{cd6}', WC_Extend), ('\u{cde}', '\u{cde}', WC_ALetter), ('\u{ce0}',
+        '\u{ce1}', WC_ALetter), ('\u{ce2}', '\u{ce3}', WC_Extend), ('\u{ce6}', '\u{cef}',
+        WC_Numeric), ('\u{cf1}', '\u{cf2}', WC_ALetter), ('\u{d01}', '\u{d03}', WC_Extend),
+        ('\u{d05}', '\u{d0c}', WC_ALetter), ('\u{d0e}', '\u{d10}', WC_ALetter), ('\u{d12}',
+        '\u{d3a}', WC_ALetter), ('\u{d3d}', '\u{d3d}', WC_ALetter), ('\u{d3e}', '\u{d44}',
+        WC_Extend), ('\u{d46}', '\u{d48}', WC_Extend), ('\u{d4a}', '\u{d4d}', WC_Extend),
+        ('\u{d4e}', '\u{d4e}', WC_ALetter), ('\u{d54}', '\u{d56}', WC_ALetter), ('\u{d57}',
+        '\u{d57}', WC_Extend), ('\u{d5f}', '\u{d61}', WC_ALetter), ('\u{d62}', '\u{d63}',
+        WC_Extend), ('\u{d66}', '\u{d6f}', WC_Numeric), ('\u{d7a}', '\u{d7f}', WC_ALetter),
+        ('\u{d82}', '\u{d83}', WC_Extend), ('\u{d85}', '\u{d96}', WC_ALetter), ('\u{d9a}',
+        '\u{db1}', WC_ALetter), ('\u{db3}', '\u{dbb}', WC_ALetter), ('\u{dbd}', '\u{dbd}',
+        WC_ALetter), ('\u{dc0}', '\u{dc6}', WC_ALetter), ('\u{dca}', '\u{dca}', WC_Extend),
+        ('\u{dcf}', '\u{dd4}', WC_Extend), ('\u{dd6}', '\u{dd6}', WC_Extend), ('\u{dd8}', '\u{ddf}',
+        WC_Extend), ('\u{de6}', '\u{def}', WC_Numeric), ('\u{df2}', '\u{df3}', WC_Extend),
+        ('\u{e31}', '\u{e31}', WC_Extend), ('\u{e34}', '\u{e3a}', WC_Extend), ('\u{e47}', '\u{e4e}',
+        WC_Extend), ('\u{e50}', '\u{e59}', WC_Numeric), ('\u{eb1}', '\u{eb1}', WC_Extend),
+        ('\u{eb4}', '\u{eb9}', WC_Extend), ('\u{ebb}', '\u{ebc}', WC_Extend), ('\u{ec8}', '\u{ecd}',
+        WC_Extend), ('\u{ed0}', '\u{ed9}', WC_Numeric), ('\u{f00}', '\u{f00}', WC_ALetter),
+        ('\u{f18}', '\u{f19}', WC_Extend), ('\u{f20}', '\u{f29}', WC_Numeric), ('\u{f35}',
+        '\u{f35}', WC_Extend), ('\u{f37}', '\u{f37}', WC_Extend), ('\u{f39}', '\u{f39}', WC_Extend),
+        ('\u{f3e}', '\u{f3f}', WC_Extend), ('\u{f40}', '\u{f47}', WC_ALetter), ('\u{f49}',
+        '\u{f6c}', WC_ALetter), ('\u{f71}', '\u{f84}', WC_Extend), ('\u{f86}', '\u{f87}',
+        WC_Extend), ('\u{f88}', '\u{f8c}', WC_ALetter), ('\u{f8d}', '\u{f97}', WC_Extend),
+        ('\u{f99}', '\u{fbc}', WC_Extend), ('\u{fc6}', '\u{fc6}', WC_Extend), ('\u{102b}',
+        '\u{103e}', WC_Extend), ('\u{1040}', '\u{1049}', WC_Numeric), ('\u{1056}', '\u{1059}',
+        WC_Extend), ('\u{105e}', '\u{1060}', WC_Extend), ('\u{1062}', '\u{1064}', WC_Extend),
+        ('\u{1067}', '\u{106d}', WC_Extend), ('\u{1071}', '\u{1074}', WC_Extend), ('\u{1082}',
+        '\u{108d}', WC_Extend), ('\u{108f}', '\u{108f}', WC_Extend), ('\u{1090}', '\u{1099}',
+        WC_Numeric), ('\u{109a}', '\u{109d}', WC_Extend), ('\u{10a0}', '\u{10c5}', WC_ALetter),
+        ('\u{10c7}', '\u{10c7}', WC_ALetter), ('\u{10cd}', '\u{10cd}', WC_ALetter), ('\u{10d0}',
+        '\u{10fa}', WC_ALetter), ('\u{10fc}', '\u{1248}', WC_ALetter), ('\u{124a}', '\u{124d}',
+        WC_ALetter), ('\u{1250}', '\u{1256}', WC_ALetter), ('\u{1258}', '\u{1258}', WC_ALetter),
+        ('\u{125a}', '\u{125d}', WC_ALetter), ('\u{1260}', '\u{1288}', WC_ALetter), ('\u{128a}',
+        '\u{128d}', WC_ALetter), ('\u{1290}', '\u{12b0}', WC_ALetter), ('\u{12b2}', '\u{12b5}',
+        WC_ALetter), ('\u{12b8}', '\u{12be}', WC_ALetter), ('\u{12c0}', '\u{12c0}', WC_ALetter),
+        ('\u{12c2}', '\u{12c5}', WC_ALetter), ('\u{12c8}', '\u{12d6}', WC_ALetter), ('\u{12d8}',
+        '\u{1310}', WC_ALetter), ('\u{1312}', '\u{1315}', WC_ALetter), ('\u{1318}', '\u{135a}',
+        WC_ALetter), ('\u{135d}', '\u{135f}', WC_Extend), ('\u{1380}', '\u{138f}', WC_ALetter),
+        ('\u{13a0}', '\u{13f5}', WC_ALetter), ('\u{13f8}', '\u{13fd}', WC_ALetter), ('\u{1401}',
+        '\u{166c}', WC_ALetter), ('\u{166f}', '\u{167f}', WC_ALetter), ('\u{1681}', '\u{169a}',
+        WC_ALetter), ('\u{16a0}', '\u{16ea}', WC_ALetter), ('\u{16ee}', '\u{16f8}', WC_ALetter),
+        ('\u{1700}', '\u{170c}', WC_ALetter), ('\u{170e}', '\u{1711}', WC_ALetter), ('\u{1712}',
+        '\u{1714}', WC_Extend), ('\u{1720}', '\u{1731}', WC_ALetter), ('\u{1732}', '\u{1734}',
+        WC_Extend), ('\u{1740}', '\u{1751}', WC_ALetter), ('\u{1752}', '\u{1753}', WC_Extend),
+        ('\u{1760}', '\u{176c}', WC_ALetter), ('\u{176e}', '\u{1770}', WC_ALetter), ('\u{1772}',
+        '\u{1773}', WC_Extend), ('\u{17b4}', '\u{17d3}', WC_Extend), ('\u{17dd}', '\u{17dd}',
+        WC_Extend), ('\u{17e0}', '\u{17e9}', WC_Numeric), ('\u{180b}', '\u{180d}', WC_Extend),
+        ('\u{180e}', '\u{180e}', WC_Format), ('\u{1810}', '\u{1819}', WC_Numeric), ('\u{1820}',
+        '\u{1877}', WC_ALetter), ('\u{1880}', '\u{1884}', WC_ALetter), ('\u{1885}', '\u{1886}',
+        WC_Extend), ('\u{1887}', '\u{18a8}', WC_ALetter), ('\u{18a9}', '\u{18a9}', WC_Extend),
+        ('\u{18aa}', '\u{18aa}', WC_ALetter), ('\u{18b0}', '\u{18f5}', WC_ALetter), ('\u{1900}',
+        '\u{191e}', WC_ALetter), ('\u{1920}', '\u{192b}', WC_Extend), ('\u{1930}', '\u{193b}',
+        WC_Extend), ('\u{1946}', '\u{194f}', WC_Numeric), ('\u{19d0}', '\u{19d9}', WC_Numeric),
+        ('\u{1a00}', '\u{1a16}', WC_ALetter), ('\u{1a17}', '\u{1a1b}', WC_Extend), ('\u{1a55}',
+        '\u{1a5e}', WC_Extend), ('\u{1a60}', '\u{1a7c}', WC_Extend), ('\u{1a7f}', '\u{1a7f}',
+        WC_Extend), ('\u{1a80}', '\u{1a89}', WC_Numeric), ('\u{1a90}', '\u{1a99}', WC_Numeric),
+        ('\u{1ab0}', '\u{1abe}', WC_Extend), ('\u{1b00}', '\u{1b04}', WC_Extend), ('\u{1b05}',
+        '\u{1b33}', WC_ALetter), ('\u{1b34}', '\u{1b44}', WC_Extend), ('\u{1b45}', '\u{1b4b}',
+        WC_ALetter), ('\u{1b50}', '\u{1b59}', WC_Numeric), ('\u{1b6b}', '\u{1b73}', WC_Extend),
+        ('\u{1b80}', '\u{1b82}', WC_Extend), ('\u{1b83}', '\u{1ba0}', WC_ALetter), ('\u{1ba1}',
+        '\u{1bad}', WC_Extend), ('\u{1bae}', '\u{1baf}', WC_ALetter), ('\u{1bb0}', '\u{1bb9}',
+        WC_Numeric), ('\u{1bba}', '\u{1be5}', WC_ALetter), ('\u{1be6}', '\u{1bf3}', WC_Extend),
+        ('\u{1c00}', '\u{1c23}', WC_ALetter), ('\u{1c24}', '\u{1c37}', WC_Extend), ('\u{1c40}',
+        '\u{1c49}', WC_Numeric), ('\u{1c4d}', '\u{1c4f}', WC_ALetter), ('\u{1c50}', '\u{1c59}',
+        WC_Numeric), ('\u{1c5a}', '\u{1c7d}', WC_ALetter), ('\u{1c80}', '\u{1c88}', WC_ALetter),
+        ('\u{1cd0}', '\u{1cd2}', WC_Extend), ('\u{1cd4}', '\u{1ce8}', WC_Extend), ('\u{1ce9}',
+        '\u{1cec}', WC_ALetter), ('\u{1ced}', '\u{1ced}', WC_Extend), ('\u{1cee}', '\u{1cf1}',
+        WC_ALetter), ('\u{1cf2}', '\u{1cf4}', WC_Extend), ('\u{1cf5}', '\u{1cf6}', WC_ALetter),
+        ('\u{1cf8}', '\u{1cf9}', WC_Extend), ('\u{1d00}', '\u{1dbf}', WC_ALetter), ('\u{1dc0}',
+        '\u{1df5}', WC_Extend), ('\u{1dfb}', '\u{1dff}', WC_Extend), ('\u{1e00}', '\u{1f15}',
+        WC_ALetter), ('\u{1f18}', '\u{1f1d}', WC_ALetter), ('\u{1f20}', '\u{1f45}', WC_ALetter),
+        ('\u{1f48}', '\u{1f4d}', WC_ALetter), ('\u{1f50}', '\u{1f57}', WC_ALetter), ('\u{1f59}',
+        '\u{1f59}', WC_ALetter), ('\u{1f5b}', '\u{1f5b}', WC_ALetter), ('\u{1f5d}', '\u{1f5d}',
+        WC_ALetter), ('\u{1f5f}', '\u{1f7d}', WC_ALetter), ('\u{1f80}', '\u{1fb4}', WC_ALetter),
+        ('\u{1fb6}', '\u{1fbc}', WC_ALetter), ('\u{1fbe}', '\u{1fbe}', WC_ALetter), ('\u{1fc2}',
+        '\u{1fc4}', WC_ALetter), ('\u{1fc6}', '\u{1fcc}', WC_ALetter), ('\u{1fd0}', '\u{1fd3}',
+        WC_ALetter), ('\u{1fd6}', '\u{1fdb}', WC_ALetter), ('\u{1fe0}', '\u{1fec}', WC_ALetter),
+        ('\u{1ff2}', '\u{1ff4}', WC_ALetter), ('\u{1ff6}', '\u{1ffc}', WC_ALetter), ('\u{200c}',
+        '\u{200c}', WC_Extend), ('\u{200d}', '\u{200d}', WC_ZWJ), ('\u{200e}', '\u{200f}',
+        WC_Format), ('\u{2018}', '\u{2019}', WC_MidNumLet), ('\u{2024}', '\u{2024}', WC_MidNumLet),
+        ('\u{2027}', '\u{2027}', WC_MidLetter), ('\u{2028}', '\u{2029}', WC_Newline), ('\u{202a}',
+        '\u{202e}', WC_Format), ('\u{202f}', '\u{202f}', WC_ExtendNumLet), ('\u{203f}', '\u{2040}',
+        WC_ExtendNumLet), ('\u{2044}', '\u{2044}', WC_MidNum), ('\u{2054}', '\u{2054}',
+        WC_ExtendNumLet), ('\u{2060}', '\u{2064}', WC_Format), ('\u{2066}', '\u{206f}', WC_Format),
+        ('\u{2071}', '\u{2071}', WC_ALetter), ('\u{207f}', '\u{207f}', WC_ALetter), ('\u{2090}',
+        '\u{209c}', WC_ALetter), ('\u{20d0}', '\u{20f0}', WC_Extend), ('\u{2102}', '\u{2102}',
+        WC_ALetter), ('\u{2107}', '\u{2107}', WC_ALetter), ('\u{210a}', '\u{2113}', WC_ALetter),
+        ('\u{2115}', '\u{2115}', WC_ALetter), ('\u{2119}', '\u{211d}', WC_ALetter), ('\u{2124}',
+        '\u{2124}', WC_ALetter), ('\u{2126}', '\u{2126}', WC_ALetter), ('\u{2128}', '\u{2128}',
+        WC_ALetter), ('\u{212a}', '\u{212d}', WC_ALetter), ('\u{212f}', '\u{2139}', WC_ALetter),
+        ('\u{213c}', '\u{213f}', WC_ALetter), ('\u{2145}', '\u{2149}', WC_ALetter), ('\u{214e}',
+        '\u{214e}', WC_ALetter), ('\u{2160}', '\u{2188}', WC_ALetter), ('\u{24b6}', '\u{24e9}',
+        WC_ALetter), ('\u{261d}', '\u{261d}', WC_E_Base), ('\u{26f9}', '\u{26f9}', WC_E_Base),
+        ('\u{270a}', '\u{270d}', WC_E_Base), ('\u{2764}', '\u{2764}', WC_Glue_After_Zwj),
+        ('\u{2c00}', '\u{2c2e}', WC_ALetter), ('\u{2c30}', '\u{2c5e}', WC_ALetter), ('\u{2c60}',
+        '\u{2ce4}', WC_ALetter), ('\u{2ceb}', '\u{2cee}', WC_ALetter), ('\u{2cef}', '\u{2cf1}',
+        WC_Extend), ('\u{2cf2}', '\u{2cf3}', WC_ALetter), ('\u{2d00}', '\u{2d25}', WC_ALetter),
+        ('\u{2d27}', '\u{2d27}', WC_ALetter), ('\u{2d2d}', '\u{2d2d}', WC_ALetter), ('\u{2d30}',
+        '\u{2d67}', WC_ALetter), ('\u{2d6f}', '\u{2d6f}', WC_ALetter), ('\u{2d7f}', '\u{2d7f}',
+        WC_Extend), ('\u{2d80}', '\u{2d96}', WC_ALetter), ('\u{2da0}', '\u{2da6}', WC_ALetter),
+        ('\u{2da8}', '\u{2dae}', WC_ALetter), ('\u{2db0}', '\u{2db6}', WC_ALetter), ('\u{2db8}',
+        '\u{2dbe}', WC_ALetter), ('\u{2dc0}', '\u{2dc6}', WC_ALetter), ('\u{2dc8}', '\u{2dce}',
+        WC_ALetter), ('\u{2dd0}', '\u{2dd6}', WC_ALetter), ('\u{2dd8}', '\u{2dde}', WC_ALetter),
+        ('\u{2de0}', '\u{2dff}', WC_Extend), ('\u{2e2f}', '\u{2e2f}', WC_ALetter), ('\u{3005}',
+        '\u{3005}', WC_ALetter), ('\u{302a}', '\u{302f}', WC_Extend), ('\u{3031}', '\u{3035}',
+        WC_Katakana), ('\u{303b}', '\u{303c}', WC_ALetter), ('\u{3099}', '\u{309a}', WC_Extend),
+        ('\u{309b}', '\u{309c}', WC_Katakana), ('\u{30a0}', '\u{30fa}', WC_Katakana), ('\u{30fc}',
+        '\u{30ff}', WC_Katakana), ('\u{3105}', '\u{312d}', WC_ALetter), ('\u{3131}', '\u{318e}',
+        WC_ALetter), ('\u{31a0}', '\u{31ba}', WC_ALetter), ('\u{31f0}', '\u{31ff}', WC_Katakana),
+        ('\u{32d0}', '\u{32fe}', WC_Katakana), ('\u{3300}', '\u{3357}', WC_Katakana), ('\u{a000}',
+        '\u{a48c}', WC_ALetter), ('\u{a4d0}', '\u{a4fd}', WC_ALetter), ('\u{a500}', '\u{a60c}',
+        WC_ALetter), ('\u{a610}', '\u{a61f}', WC_ALetter), ('\u{a620}', '\u{a629}', WC_Numeric),
+        ('\u{a62a}', '\u{a62b}', WC_ALetter), ('\u{a640}', '\u{a66e}', WC_ALetter), ('\u{a66f}',
+        '\u{a672}', WC_Extend), ('\u{a674}', '\u{a67d}', WC_Extend), ('\u{a67f}', '\u{a69d}',
+        WC_ALetter), ('\u{a69e}', '\u{a69f}', WC_Extend), ('\u{a6a0}', '\u{a6ef}', WC_ALetter),
+        ('\u{a6f0}', '\u{a6f1}', WC_Extend), ('\u{a717}', '\u{a71f}', WC_ALetter), ('\u{a722}',
+        '\u{a788}', WC_ALetter), ('\u{a78b}', '\u{a7ae}', WC_ALetter), ('\u{a7b0}', '\u{a7b7}',
+        WC_ALetter), ('\u{a7f7}', '\u{a801}', WC_ALetter), ('\u{a802}', '\u{a802}', WC_Extend),
+        ('\u{a803}', '\u{a805}', WC_ALetter), ('\u{a806}', '\u{a806}', WC_Extend), ('\u{a807}',
+        '\u{a80a}', WC_ALetter), ('\u{a80b}', '\u{a80b}', WC_Extend), ('\u{a80c}', '\u{a822}',
+        WC_ALetter), ('\u{a823}', '\u{a827}', WC_Extend), ('\u{a840}', '\u{a873}', WC_ALetter),
+        ('\u{a880}', '\u{a881}', WC_Extend), ('\u{a882}', '\u{a8b3}', WC_ALetter), ('\u{a8b4}',
+        '\u{a8c5}', WC_Extend), ('\u{a8d0}', '\u{a8d9}', WC_Numeric), ('\u{a8e0}', '\u{a8f1}',
+        WC_Extend), ('\u{a8f2}', '\u{a8f7}', WC_ALetter), ('\u{a8fb}', '\u{a8fb}', WC_ALetter),
+        ('\u{a8fd}', '\u{a8fd}', WC_ALetter), ('\u{a900}', '\u{a909}', WC_Numeric), ('\u{a90a}',
+        '\u{a925}', WC_ALetter), ('\u{a926}', '\u{a92d}', WC_Extend), ('\u{a930}', '\u{a946}',
+        WC_ALetter), ('\u{a947}', '\u{a953}', WC_Extend), ('\u{a960}', '\u{a97c}', WC_ALetter),
+        ('\u{a980}', '\u{a983}', WC_Extend), ('\u{a984}', '\u{a9b2}', WC_ALetter), ('\u{a9b3}',
+        '\u{a9c0}', WC_Extend), ('\u{a9cf}', '\u{a9cf}', WC_ALetter), ('\u{a9d0}', '\u{a9d9}',
+        WC_Numeric), ('\u{a9e5}', '\u{a9e5}', WC_Extend), ('\u{a9f0}', '\u{a9f9}', WC_Numeric),
+        ('\u{aa00}', '\u{aa28}', WC_ALetter), ('\u{aa29}', '\u{aa36}', WC_Extend), ('\u{aa40}',
+        '\u{aa42}', WC_ALetter), ('\u{aa43}', '\u{aa43}', WC_Extend), ('\u{aa44}', '\u{aa4b}',
+        WC_ALetter), ('\u{aa4c}', '\u{aa4d}', WC_Extend), ('\u{aa50}', '\u{aa59}', WC_Numeric),
+        ('\u{aa7b}', '\u{aa7d}', WC_Extend), ('\u{aab0}', '\u{aab0}', WC_Extend), ('\u{aab2}',
+        '\u{aab4}', WC_Extend), ('\u{aab7}', '\u{aab8}', WC_Extend), ('\u{aabe}', '\u{aabf}',
+        WC_Extend), ('\u{aac1}', '\u{aac1}', WC_Extend), ('\u{aae0}', '\u{aaea}', WC_ALetter),
+        ('\u{aaeb}', '\u{aaef}', WC_Extend), ('\u{aaf2}', '\u{aaf4}', WC_ALetter), ('\u{aaf5}',
+        '\u{aaf6}', WC_Extend), ('\u{ab01}', '\u{ab06}', WC_ALetter), ('\u{ab09}', '\u{ab0e}',
+        WC_ALetter), ('\u{ab11}', '\u{ab16}', WC_ALetter), ('\u{ab20}', '\u{ab26}', WC_ALetter),
+        ('\u{ab28}', '\u{ab2e}', WC_ALetter), ('\u{ab30}', '\u{ab5a}', WC_ALetter), ('\u{ab5c}',
+        '\u{ab65}', WC_ALetter), ('\u{ab70}', '\u{abe2}', WC_ALetter), ('\u{abe3}', '\u{abea}',
+        WC_Extend), ('\u{abec}', '\u{abed}', WC_Extend), ('\u{abf0}', '\u{abf9}', WC_Numeric),
+        ('\u{ac00}', '\u{d7a3}', WC_ALetter), ('\u{d7b0}', '\u{d7c6}', WC_ALetter), ('\u{d7cb}',
+        '\u{d7fb}', WC_ALetter), ('\u{fb00}', '\u{fb06}', WC_ALetter), ('\u{fb13}', '\u{fb17}',
+        WC_ALetter), ('\u{fb1d}', '\u{fb1d}', WC_Hebrew_Letter), ('\u{fb1e}', '\u{fb1e}',
+        WC_Extend), ('\u{fb1f}', '\u{fb28}', WC_Hebrew_Letter), ('\u{fb2a}', '\u{fb36}',
+        WC_Hebrew_Letter), ('\u{fb38}', '\u{fb3c}', WC_Hebrew_Letter), ('\u{fb3e}', '\u{fb3e}',
+        WC_Hebrew_Letter), ('\u{fb40}', '\u{fb41}', WC_Hebrew_Letter), ('\u{fb43}', '\u{fb44}',
+        WC_Hebrew_Letter), ('\u{fb46}', '\u{fb4f}', WC_Hebrew_Letter), ('\u{fb50}', '\u{fbb1}',
+        WC_ALetter), ('\u{fbd3}', '\u{fd3d}', WC_ALetter), ('\u{fd50}', '\u{fd8f}', WC_ALetter),
+        ('\u{fd92}', '\u{fdc7}', WC_ALetter), ('\u{fdf0}', '\u{fdfb}', WC_ALetter), ('\u{fe00}',
+        '\u{fe0f}', WC_Extend), ('\u{fe10}', '\u{fe10}', WC_MidNum), ('\u{fe13}', '\u{fe13}',
+        WC_MidLetter), ('\u{fe14}', '\u{fe14}', WC_MidNum), ('\u{fe20}', '\u{fe2f}', WC_Extend),
+        ('\u{fe33}', '\u{fe34}', WC_ExtendNumLet), ('\u{fe4d}', '\u{fe4f}', WC_ExtendNumLet),
+        ('\u{fe50}', '\u{fe50}', WC_MidNum), ('\u{fe52}', '\u{fe52}', WC_MidNumLet), ('\u{fe54}',
+        '\u{fe54}', WC_MidNum), ('\u{fe55}', '\u{fe55}', WC_MidLetter), ('\u{fe70}', '\u{fe74}',
+        WC_ALetter), ('\u{fe76}', '\u{fefc}', WC_ALetter), ('\u{feff}', '\u{feff}', WC_Format),
+        ('\u{ff07}', '\u{ff07}', WC_MidNumLet), ('\u{ff0c}', '\u{ff0c}', WC_MidNum), ('\u{ff0e}',
+        '\u{ff0e}', WC_MidNumLet), ('\u{ff1a}', '\u{ff1a}', WC_MidLetter), ('\u{ff1b}', '\u{ff1b}',
+        WC_MidNum), ('\u{ff21}', '\u{ff3a}', WC_ALetter), ('\u{ff3f}', '\u{ff3f}', WC_ExtendNumLet),
+        ('\u{ff41}', '\u{ff5a}', WC_ALetter), ('\u{ff66}', '\u{ff9d}', WC_Katakana), ('\u{ff9e}',
+        '\u{ff9f}', WC_Extend), ('\u{ffa0}', '\u{ffbe}', WC_ALetter), ('\u{ffc2}', '\u{ffc7}',
+        WC_ALetter), ('\u{ffca}', '\u{ffcf}', WC_ALetter), ('\u{ffd2}', '\u{ffd7}', WC_ALetter),
+        ('\u{ffda}', '\u{ffdc}', WC_ALetter), ('\u{fff9}', '\u{fffb}', WC_Format), ('\u{10000}',
+        '\u{1000b}', WC_ALetter), ('\u{1000d}', '\u{10026}', WC_ALetter), ('\u{10028}', '\u{1003a}',
+        WC_ALetter), ('\u{1003c}', '\u{1003d}', WC_ALetter), ('\u{1003f}', '\u{1004d}', WC_ALetter),
+        ('\u{10050}', '\u{1005d}', WC_ALetter), ('\u{10080}', '\u{100fa}', WC_ALetter),
+        ('\u{10140}', '\u{10174}', WC_ALetter), ('\u{101fd}', '\u{101fd}', WC_Extend), ('\u{10280}',
+        '\u{1029c}', WC_ALetter), ('\u{102a0}', '\u{102d0}', WC_ALetter), ('\u{102e0}', '\u{102e0}',
+        WC_Extend), ('\u{10300}', '\u{1031f}', WC_ALetter), ('\u{10330}', '\u{1034a}', WC_ALetter),
+        ('\u{10350}', '\u{10375}', WC_ALetter), ('\u{10376}', '\u{1037a}', WC_Extend), ('\u{10380}',
+        '\u{1039d}', WC_ALetter), ('\u{103a0}', '\u{103c3}', WC_ALetter), ('\u{103c8}', '\u{103cf}',
+        WC_ALetter), ('\u{103d1}', '\u{103d5}', WC_ALetter), ('\u{10400}', '\u{1049d}', WC_ALetter),
+        ('\u{104a0}', '\u{104a9}', WC_Numeric), ('\u{104b0}', '\u{104d3}', WC_ALetter),
+        ('\u{104d8}', '\u{104fb}', WC_ALetter), ('\u{10500}', '\u{10527}', WC_ALetter),
+        ('\u{10530}', '\u{10563}', WC_ALetter), ('\u{10600}', '\u{10736}', WC_ALetter),
+        ('\u{10740}', '\u{10755}', WC_ALetter), ('\u{10760}', '\u{10767}', WC_ALetter),
+        ('\u{10800}', '\u{10805}', WC_ALetter), ('\u{10808}', '\u{10808}', WC_ALetter),
+        ('\u{1080a}', '\u{10835}', WC_ALetter), ('\u{10837}', '\u{10838}', WC_ALetter),
+        ('\u{1083c}', '\u{1083c}', WC_ALetter), ('\u{1083f}', '\u{10855}', WC_ALetter),
+        ('\u{10860}', '\u{10876}', WC_ALetter), ('\u{10880}', '\u{1089e}', WC_ALetter),
+        ('\u{108e0}', '\u{108f2}', WC_ALetter), ('\u{108f4}', '\u{108f5}', WC_ALetter),
+        ('\u{10900}', '\u{10915}', WC_ALetter), ('\u{10920}', '\u{10939}', WC_ALetter),
+        ('\u{10980}', '\u{109b7}', WC_ALetter), ('\u{109be}', '\u{109bf}', WC_ALetter),
+        ('\u{10a00}', '\u{10a00}', WC_ALetter), ('\u{10a01}', '\u{10a03}', WC_Extend), ('\u{10a05}',
+        '\u{10a06}', WC_Extend), ('\u{10a0c}', '\u{10a0f}', WC_Extend), ('\u{10a10}', '\u{10a13}',
+        WC_ALetter), ('\u{10a15}', '\u{10a17}', WC_ALetter), ('\u{10a19}', '\u{10a33}', WC_ALetter),
+        ('\u{10a38}', '\u{10a3a}', WC_Extend), ('\u{10a3f}', '\u{10a3f}', WC_Extend), ('\u{10a60}',
+        '\u{10a7c}', WC_ALetter), ('\u{10a80}', '\u{10a9c}', WC_ALetter), ('\u{10ac0}', '\u{10ac7}',
+        WC_ALetter), ('\u{10ac9}', '\u{10ae4}', WC_ALetter), ('\u{10ae5}', '\u{10ae6}', WC_Extend),
+        ('\u{10b00}', '\u{10b35}', WC_ALetter), ('\u{10b40}', '\u{10b55}', WC_ALetter),
+        ('\u{10b60}', '\u{10b72}', WC_ALetter), ('\u{10b80}', '\u{10b91}', WC_ALetter),
+        ('\u{10c00}', '\u{10c48}', WC_ALetter), ('\u{10c80}', '\u{10cb2}', WC_ALetter),
+        ('\u{10cc0}', '\u{10cf2}', WC_ALetter), ('\u{11000}', '\u{11002}', WC_Extend), ('\u{11003}',
+        '\u{11037}', WC_ALetter), ('\u{11038}', '\u{11046}', WC_Extend), ('\u{11066}', '\u{1106f}',
+        WC_Numeric), ('\u{1107f}', '\u{11082}', WC_Extend), ('\u{11083}', '\u{110af}', WC_ALetter),
+        ('\u{110b0}', '\u{110ba}', WC_Extend), ('\u{110bd}', '\u{110bd}', WC_Format), ('\u{110d0}',
+        '\u{110e8}', WC_ALetter), ('\u{110f0}', '\u{110f9}', WC_Numeric), ('\u{11100}', '\u{11102}',
+        WC_Extend), ('\u{11103}', '\u{11126}', WC_ALetter), ('\u{11127}', '\u{11134}', WC_Extend),
+        ('\u{11136}', '\u{1113f}', WC_Numeric), ('\u{11150}', '\u{11172}', WC_ALetter),
+        ('\u{11173}', '\u{11173}', WC_Extend), ('\u{11176}', '\u{11176}', WC_ALetter), ('\u{11180}',
+        '\u{11182}', WC_Extend), ('\u{11183}', '\u{111b2}', WC_ALetter), ('\u{111b3}', '\u{111c0}',
+        WC_Extend), ('\u{111c1}', '\u{111c4}', WC_ALetter), ('\u{111ca}', '\u{111cc}', WC_Extend),
+        ('\u{111d0}', '\u{111d9}', WC_Numeric), ('\u{111da}', '\u{111da}', WC_ALetter),
+        ('\u{111dc}', '\u{111dc}', WC_ALetter), ('\u{11200}', '\u{11211}', WC_ALetter),
+        ('\u{11213}', '\u{1122b}', WC_ALetter), ('\u{1122c}', '\u{11237}', WC_Extend), ('\u{1123e}',
+        '\u{1123e}', WC_Extend), ('\u{11280}', '\u{11286}', WC_ALetter), ('\u{11288}', '\u{11288}',
+        WC_ALetter), ('\u{1128a}', '\u{1128d}', WC_ALetter), ('\u{1128f}', '\u{1129d}', WC_ALetter),
+        ('\u{1129f}', '\u{112a8}', WC_ALetter), ('\u{112b0}', '\u{112de}', WC_ALetter),
+        ('\u{112df}', '\u{112ea}', WC_Extend), ('\u{112f0}', '\u{112f9}', WC_Numeric), ('\u{11300}',
+        '\u{11303}', WC_Extend), ('\u{11305}', '\u{1130c}', WC_ALetter), ('\u{1130f}', '\u{11310}',
+        WC_ALetter), ('\u{11313}', '\u{11328}', WC_ALetter), ('\u{1132a}', '\u{11330}', WC_ALetter),
+        ('\u{11332}', '\u{11333}', WC_ALetter), ('\u{11335}', '\u{11339}', WC_ALetter),
+        ('\u{1133c}', '\u{1133c}', WC_Extend), ('\u{1133d}', '\u{1133d}', WC_ALetter), ('\u{1133e}',
+        '\u{11344}', WC_Extend), ('\u{11347}', '\u{11348}', WC_Extend), ('\u{1134b}', '\u{1134d}',
+        WC_Extend), ('\u{11350}', '\u{11350}', WC_ALetter), ('\u{11357}', '\u{11357}', WC_Extend),
+        ('\u{1135d}', '\u{11361}', WC_ALetter), ('\u{11362}', '\u{11363}', WC_Extend), ('\u{11366}',
+        '\u{1136c}', WC_Extend), ('\u{11370}', '\u{11374}', WC_Extend), ('\u{11400}', '\u{11434}',
+        WC_ALetter), ('\u{11435}', '\u{11446}', WC_Extend), ('\u{11447}', '\u{1144a}', WC_ALetter),
+        ('\u{11450}', '\u{11459}', WC_Numeric), ('\u{11480}', '\u{114af}', WC_ALetter),
+        ('\u{114b0}', '\u{114c3}', WC_Extend), ('\u{114c4}', '\u{114c5}', WC_ALetter), ('\u{114c7}',
+        '\u{114c7}', WC_ALetter), ('\u{114d0}', '\u{114d9}', WC_Numeric), ('\u{11580}', '\u{115ae}',
+        WC_ALetter), ('\u{115af}', '\u{115b5}', WC_Extend), ('\u{115b8}', '\u{115c0}', WC_Extend),
+        ('\u{115d8}', '\u{115db}', WC_ALetter), ('\u{115dc}', '\u{115dd}', WC_Extend), ('\u{11600}',
+        '\u{1162f}', WC_ALetter), ('\u{11630}', '\u{11640}', WC_Extend), ('\u{11644}', '\u{11644}',
+        WC_ALetter), ('\u{11650}', '\u{11659}', WC_Numeric), ('\u{11680}', '\u{116aa}', WC_ALetter),
+        ('\u{116ab}', '\u{116b7}', WC_Extend), ('\u{116c0}', '\u{116c9}', WC_Numeric), ('\u{1171d}',
+        '\u{1172b}', WC_Extend), ('\u{11730}', '\u{11739}', WC_Numeric), ('\u{118a0}', '\u{118df}',
+        WC_ALetter), ('\u{118e0}', '\u{118e9}', WC_Numeric), ('\u{118ff}', '\u{118ff}', WC_ALetter),
+        ('\u{11ac0}', '\u{11af8}', WC_ALetter), ('\u{11c00}', '\u{11c08}', WC_ALetter),
+        ('\u{11c0a}', '\u{11c2e}', WC_ALetter), ('\u{11c2f}', '\u{11c36}', WC_Extend), ('\u{11c38}',
+        '\u{11c3f}', WC_Extend), ('\u{11c40}', '\u{11c40}', WC_ALetter), ('\u{11c50}', '\u{11c59}',
+        WC_Numeric), ('\u{11c72}', '\u{11c8f}', WC_ALetter), ('\u{11c92}', '\u{11ca7}', WC_Extend),
+        ('\u{11ca9}', '\u{11cb6}', WC_Extend), ('\u{12000}', '\u{12399}', WC_ALetter), ('\u{12400}',
+        '\u{1246e}', WC_ALetter), ('\u{12480}', '\u{12543}', WC_ALetter), ('\u{13000}', '\u{1342e}',
+        WC_ALetter), ('\u{14400}', '\u{14646}', WC_ALetter), ('\u{16800}', '\u{16a38}', WC_ALetter),
+        ('\u{16a40}', '\u{16a5e}', WC_ALetter), ('\u{16a60}', '\u{16a69}', WC_Numeric),
+        ('\u{16ad0}', '\u{16aed}', WC_ALetter), ('\u{16af0}', '\u{16af4}', WC_Extend), ('\u{16b00}',
+        '\u{16b2f}', WC_ALetter), ('\u{16b30}', '\u{16b36}', WC_Extend), ('\u{16b40}', '\u{16b43}',
+        WC_ALetter), ('\u{16b50}', '\u{16b59}', WC_Numeric), ('\u{16b63}', '\u{16b77}', WC_ALetter),
+        ('\u{16b7d}', '\u{16b8f}', WC_ALetter), ('\u{16f00}', '\u{16f44}', WC_ALetter),
+        ('\u{16f50}', '\u{16f50}', WC_ALetter), ('\u{16f51}', '\u{16f7e}', WC_Extend), ('\u{16f8f}',
+        '\u{16f92}', WC_Extend), ('\u{16f93}', '\u{16f9f}', WC_ALetter), ('\u{16fe0}', '\u{16fe0}',
+        WC_ALetter), ('\u{1b000}', '\u{1b000}', WC_Katakana), ('\u{1bc00}', '\u{1bc6a}',
+        WC_ALetter), ('\u{1bc70}', '\u{1bc7c}', WC_ALetter), ('\u{1bc80}', '\u{1bc88}', WC_ALetter),
+        ('\u{1bc90}', '\u{1bc99}', WC_ALetter), ('\u{1bc9d}', '\u{1bc9e}', WC_Extend), ('\u{1bca0}',
+        '\u{1bca3}', WC_Format), ('\u{1d165}', '\u{1d169}', WC_Extend), ('\u{1d16d}', '\u{1d172}',
+        WC_Extend), ('\u{1d173}', '\u{1d17a}', WC_Format), ('\u{1d17b}', '\u{1d182}', WC_Extend),
+        ('\u{1d185}', '\u{1d18b}', WC_Extend), ('\u{1d1aa}', '\u{1d1ad}', WC_Extend), ('\u{1d242}',
+        '\u{1d244}', WC_Extend), ('\u{1d400}', '\u{1d454}', WC_ALetter), ('\u{1d456}', '\u{1d49c}',
+        WC_ALetter), ('\u{1d49e}', '\u{1d49f}', WC_ALetter), ('\u{1d4a2}', '\u{1d4a2}', WC_ALetter),
+        ('\u{1d4a5}', '\u{1d4a6}', WC_ALetter), ('\u{1d4a9}', '\u{1d4ac}', WC_ALetter),
+        ('\u{1d4ae}', '\u{1d4b9}', WC_ALetter), ('\u{1d4bb}', '\u{1d4bb}', WC_ALetter),
+        ('\u{1d4bd}', '\u{1d4c3}', WC_ALetter), ('\u{1d4c5}', '\u{1d505}', WC_ALetter),
+        ('\u{1d507}', '\u{1d50a}', WC_ALetter), ('\u{1d50d}', '\u{1d514}', WC_ALetter),
+        ('\u{1d516}', '\u{1d51c}', WC_ALetter), ('\u{1d51e}', '\u{1d539}', WC_ALetter),
+        ('\u{1d53b}', '\u{1d53e}', WC_ALetter), ('\u{1d540}', '\u{1d544}', WC_ALetter),
+        ('\u{1d546}', '\u{1d546}', WC_ALetter), ('\u{1d54a}', '\u{1d550}', WC_ALetter),
+        ('\u{1d552}', '\u{1d6a5}', WC_ALetter), ('\u{1d6a8}', '\u{1d6c0}', WC_ALetter),
+        ('\u{1d6c2}', '\u{1d6da}', WC_ALetter), ('\u{1d6dc}', '\u{1d6fa}', WC_ALetter),
+        ('\u{1d6fc}', '\u{1d714}', WC_ALetter), ('\u{1d716}', '\u{1d734}', WC_ALetter),
+        ('\u{1d736}', '\u{1d74e}', WC_ALetter), ('\u{1d750}', '\u{1d76e}', WC_ALetter),
+        ('\u{1d770}', '\u{1d788}', WC_ALetter), ('\u{1d78a}', '\u{1d7a8}', WC_ALetter),
+        ('\u{1d7aa}', '\u{1d7c2}', WC_ALetter), ('\u{1d7c4}', '\u{1d7cb}', WC_ALetter),
+        ('\u{1d7ce}', '\u{1d7ff}', WC_Numeric), ('\u{1da00}', '\u{1da36}', WC_Extend), ('\u{1da3b}',
+        '\u{1da6c}', WC_Extend), ('\u{1da75}', '\u{1da75}', WC_Extend), ('\u{1da84}', '\u{1da84}',
+        WC_Extend), ('\u{1da9b}', '\u{1da9f}', WC_Extend), ('\u{1daa1}', '\u{1daaf}', WC_Extend),
+        ('\u{1e000}', '\u{1e006}', WC_Extend), ('\u{1e008}', '\u{1e018}', WC_Extend), ('\u{1e01b}',
+        '\u{1e021}', WC_Extend), ('\u{1e023}', '\u{1e024}', WC_Extend), ('\u{1e026}', '\u{1e02a}',
+        WC_Extend), ('\u{1e800}', '\u{1e8c4}', WC_ALetter), ('\u{1e8d0}', '\u{1e8d6}', WC_Extend),
+        ('\u{1e900}', '\u{1e943}', WC_ALetter), ('\u{1e944}', '\u{1e94a}', WC_Extend), ('\u{1e950}',
+        '\u{1e959}', WC_Numeric), ('\u{1ee00}', '\u{1ee03}', WC_ALetter), ('\u{1ee05}', '\u{1ee1f}',
+        WC_ALetter), ('\u{1ee21}', '\u{1ee22}', WC_ALetter), ('\u{1ee24}', '\u{1ee24}', WC_ALetter),
+        ('\u{1ee27}', '\u{1ee27}', WC_ALetter), ('\u{1ee29}', '\u{1ee32}', WC_ALetter),
+        ('\u{1ee34}', '\u{1ee37}', WC_ALetter), ('\u{1ee39}', '\u{1ee39}', WC_ALetter),
+        ('\u{1ee3b}', '\u{1ee3b}', WC_ALetter), ('\u{1ee42}', '\u{1ee42}', WC_ALetter),
+        ('\u{1ee47}', '\u{1ee47}', WC_ALetter), ('\u{1ee49}', '\u{1ee49}', WC_ALetter),
+        ('\u{1ee4b}', '\u{1ee4b}', WC_ALetter), ('\u{1ee4d}', '\u{1ee4f}', WC_ALetter),
+        ('\u{1ee51}', '\u{1ee52}', WC_ALetter), ('\u{1ee54}', '\u{1ee54}', WC_ALetter),
+        ('\u{1ee57}', '\u{1ee57}', WC_ALetter), ('\u{1ee59}', '\u{1ee59}', WC_ALetter),
+        ('\u{1ee5b}', '\u{1ee5b}', WC_ALetter), ('\u{1ee5d}', '\u{1ee5d}', WC_ALetter),
+        ('\u{1ee5f}', '\u{1ee5f}', WC_ALetter), ('\u{1ee61}', '\u{1ee62}', WC_ALetter),
+        ('\u{1ee64}', '\u{1ee64}', WC_ALetter), ('\u{1ee67}', '\u{1ee6a}', WC_ALetter),
+        ('\u{1ee6c}', '\u{1ee72}', WC_ALetter), ('\u{1ee74}', '\u{1ee77}', WC_ALetter),
+        ('\u{1ee79}', '\u{1ee7c}', WC_ALetter), ('\u{1ee7e}', '\u{1ee7e}', WC_ALetter),
+        ('\u{1ee80}', '\u{1ee89}', WC_ALetter), ('\u{1ee8b}', '\u{1ee9b}', WC_ALetter),
+        ('\u{1eea1}', '\u{1eea3}', WC_ALetter), ('\u{1eea5}', '\u{1eea9}', WC_ALetter),
+        ('\u{1eeab}', '\u{1eebb}', WC_ALetter), ('\u{1f130}', '\u{1f149}', WC_ALetter),
+        ('\u{1f150}', '\u{1f169}', WC_ALetter), ('\u{1f170}', '\u{1f189}', WC_ALetter),
+        ('\u{1f1e6}', '\u{1f1ff}', WC_Regional_Indicator), ('\u{1f385}', '\u{1f385}', WC_E_Base),
+        ('\u{1f3c3}', '\u{1f3c4}', WC_E_Base), ('\u{1f3ca}', '\u{1f3cb}', WC_E_Base), ('\u{1f3fb}',
+        '\u{1f3ff}', WC_E_Modifier), ('\u{1f442}', '\u{1f443}', WC_E_Base), ('\u{1f446}',
+        '\u{1f450}', WC_E_Base), ('\u{1f466}', '\u{1f469}', WC_E_Base_GAZ), ('\u{1f46e}',
+        '\u{1f46e}', WC_E_Base), ('\u{1f470}', '\u{1f478}', WC_E_Base), ('\u{1f47c}', '\u{1f47c}',
+        WC_E_Base), ('\u{1f481}', '\u{1f483}', WC_E_Base), ('\u{1f485}', '\u{1f487}', WC_E_Base),
+        ('\u{1f48b}', '\u{1f48b}', WC_Glue_After_Zwj), ('\u{1f4aa}', '\u{1f4aa}', WC_E_Base),
+        ('\u{1f575}', '\u{1f575}', WC_E_Base), ('\u{1f57a}', '\u{1f57a}', WC_E_Base), ('\u{1f590}',
+        '\u{1f590}', WC_E_Base), ('\u{1f595}', '\u{1f596}', WC_E_Base), ('\u{1f5e8}', '\u{1f5e8}',
+        WC_Glue_After_Zwj), ('\u{1f645}', '\u{1f647}', WC_E_Base), ('\u{1f64b}', '\u{1f64f}',
+        WC_E_Base), ('\u{1f6a3}', '\u{1f6a3}', WC_E_Base), ('\u{1f6b4}', '\u{1f6b6}', WC_E_Base),
+        ('\u{1f6c0}', '\u{1f6c0}', WC_E_Base), ('\u{1f918}', '\u{1f91e}', WC_E_Base), ('\u{1f926}',
+        '\u{1f926}', WC_E_Base), ('\u{1f930}', '\u{1f930}', WC_E_Base), ('\u{1f933}', '\u{1f939}',
+        WC_E_Base), ('\u{1f93c}', '\u{1f93e}', WC_E_Base), ('\u{e0001}', '\u{e0001}', WC_Format),
+        ('\u{e0020}', '\u{e007f}', WC_Extend), ('\u{e0100}', '\u{e01ef}', WC_Extend)
+    ];
+
+}
diff --git a/rustc_deps/vendor/unicode-segmentation/src/test.rs b/rustc_deps/vendor/unicode-segmentation/src/test.rs
new file mode 100644
index 0000000..54493fe
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/src/test.rs
@@ -0,0 +1,176 @@
+// 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::UnicodeSegmentation;
+
+use std::prelude::v1::*;
+
+#[test]
+fn test_graphemes() {
+    use testdata::{TEST_SAME, TEST_DIFF};
+
+    pub const EXTRA_DIFF: &'static [(&'static str,
+                                     &'static [&'static str],
+                                     &'static [&'static str])] = &[
+        // Official test suite doesn't include two Prepend chars between two other chars.
+        ("\u{20}\u{600}\u{600}\u{20}",
+         &["\u{20}", "\u{600}\u{600}\u{20}"],
+         &["\u{20}", "\u{600}", "\u{600}", "\u{20}"]),
+
+        // Test for Prepend followed by two Any chars
+        ("\u{600}\u{20}\u{20}",
+         &["\u{600}\u{20}", "\u{20}"],
+         &["\u{600}", "\u{20}", "\u{20}"]),
+    ];
+
+    pub const EXTRA_SAME: &'static [(&'static str, &'static [&'static str])] = &[
+        // family emoji (more than two emoji joined by ZWJ)
+        ("\u{1f468}\u{200d}\u{1f467}\u{200d}\u{1f466}",
+         &["\u{1f468}\u{200d}\u{1f467}\u{200d}\u{1f466}"]),
+        // cartwheel emoji followed by two fitzpatrick skin tone modifiers
+        // (test case from issue #19)
+        ("\u{1F938}\u{1F3FE}\u{1F3FE}",
+         &["\u{1F938}\u{1F3FE}", "\u{1F3FE}"]),
+    ];
+
+    for &(s, g) in TEST_SAME.iter().chain(EXTRA_SAME) {
+        // test forward iterator
+        assert!(UnicodeSegmentation::graphemes(s, true).eq(g.iter().cloned()));
+        assert!(UnicodeSegmentation::graphemes(s, false).eq(g.iter().cloned()));
+
+        // test reverse iterator
+        assert!(UnicodeSegmentation::graphemes(s, true).rev().eq(g.iter().rev().cloned()));
+        assert!(UnicodeSegmentation::graphemes(s, false).rev().eq(g.iter().rev().cloned()));
+    }
+
+    for &(s, gt, gf) in TEST_DIFF.iter().chain(EXTRA_DIFF) {
+        // test forward iterator
+        assert!(UnicodeSegmentation::graphemes(s, true).eq(gt.iter().cloned()));
+        assert!(UnicodeSegmentation::graphemes(s, false).eq(gf.iter().cloned()));
+
+        // test reverse iterator
+        assert!(UnicodeSegmentation::graphemes(s, true).rev().eq(gt.iter().rev().cloned()));
+        assert!(UnicodeSegmentation::graphemes(s, false).rev().eq(gf.iter().rev().cloned()));
+    }
+
+    // test the indices iterators
+    let s = "a̐éö̲\r\n";
+    let gr_inds = UnicodeSegmentation::grapheme_indices(s, true).collect::<Vec<(usize, &str)>>();
+    let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+    assert_eq!(gr_inds, b);
+    let gr_inds = UnicodeSegmentation::grapheme_indices(s, true).rev().collect::<Vec<(usize, &str)>>();
+    let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
+    assert_eq!(gr_inds, b);
+    let mut gr_inds_iter = UnicodeSegmentation::grapheme_indices(s, true);
+    {
+        let gr_inds = gr_inds_iter.by_ref();
+        let e1 = gr_inds.size_hint();
+        assert_eq!(e1, (1, Some(13)));
+        let c = gr_inds.count();
+        assert_eq!(c, 4);
+    }
+    let e2 = gr_inds_iter.size_hint();
+    assert_eq!(e2, (0, Some(0)));
+
+    // make sure the reverse iterator does the right thing with "\n" at beginning of string
+    let s = "\n\r\n\r";
+    let gr = UnicodeSegmentation::graphemes(s, true).rev().collect::<Vec<&str>>();
+    let b: &[_] = &["\r", "\r\n", "\n"];
+    assert_eq!(gr, b);
+}
+
+#[test]
+fn test_words() {
+    use testdata::TEST_WORD;
+
+    // Unicode's official tests don't really test longer chains of flag emoji
+    // TODO This could be improved with more tests like flag emoji with interspersed Extend chars and ZWJ
+    const EXTRA_TESTS: &'static [(&'static str, &'static [&'static str])] = &[
+        ("🇦🇫🇦🇽🇦🇱🇩🇿🇦🇸🇦🇩🇦🇴", &["🇦🇫", "🇦🇽", "🇦🇱", "🇩🇿", "🇦🇸", "🇦🇩", "🇦🇴"]),
+        ("🇦🇫🇦🇽🇦🇱🇩🇿🇦🇸🇦🇩🇦", &["🇦🇫", "🇦🇽", "🇦🇱", "🇩🇿", "🇦🇸", "🇦🇩", "🇦"]),
+        ("🇦a🇫🇦🇽a🇦🇱🇩🇿🇦🇸🇦🇩🇦", &["🇦", "a", "🇫🇦", "🇽", "a", "🇦🇱", "🇩🇿", "🇦🇸", "🇦🇩", "🇦"]),
+        ("\u{1f468}\u{200d}\u{1f468}\u{200d}\u{1f466}",  &["\u{1f468}\u{200d}\u{1f468}\u{200d}\u{1f466}"]),
+        ("😌👎🏼",  &["😌", "👎🏼"]),
+        // perhaps wrong, spaces should not be included?
+        ("hello world", &["hello", " ", "world"]),
+        ("🇨🇦🇨🇭🇿🇲🇿 hi", &["🇨🇦", "🇨🇭", "🇿🇲", "🇿", " ", "hi"]),
+    ];
+    for &(s, w) in TEST_WORD.iter().chain(EXTRA_TESTS.iter()) {
+        macro_rules! assert_ {
+            ($test:expr, $exp:expr, $name:expr) => {
+                // collect into vector for better diagnostics in failure case
+                let testing = $test.collect::<Vec<_>>();
+                let expected = $exp.collect::<Vec<_>>();
+                assert_eq!(testing, expected, "{} test for testcase ({:?}, {:?}) failed.", $name, s, w)
+            }
+        }
+        // test forward iterator
+        assert_!(s.split_word_bounds(),
+                w.iter().cloned(),
+                "Forward word boundaries");
+
+        // test reverse iterator
+        assert_!(s.split_word_bounds().rev(),
+                w.iter().rev().cloned(),
+                "Reverse word boundaries");
+
+        // generate offsets from word string lengths
+        let mut indices = vec![0];
+        for i in w.iter().cloned().map(|s| s.len()).scan(0, |t, n| { *t += n; Some(*t) }) {
+            indices.push(i);
+        }
+        indices.pop();
+        let indices = indices;
+
+        // test forward indices iterator
+        assert_!(s.split_word_bound_indices().map(|(l,_)| l),
+                 indices.iter().cloned(),
+                 "Forward word indices");
+
+        // test backward indices iterator
+        assert_!(s.split_word_bound_indices().rev().map(|(l,_)| l),
+                 indices.iter().rev().cloned(),
+                 "Reverse word indices");
+    }
+}
+
+quickcheck! {
+    fn quickcheck_forward_reverse_graphemes_extended(s: String) -> bool {
+        let a = s.graphemes(true).collect::<Vec<_>>();
+        let mut b = s.graphemes(true).rev().collect::<Vec<_>>();
+        b.reverse();
+        a == b
+    }
+
+    fn quickcheck_forward_reverse_graphemes_legacy(s: String) -> bool {
+        let a = s.graphemes(false).collect::<Vec<_>>();
+        let mut b = s.graphemes(false).rev().collect::<Vec<_>>();
+        b.reverse();
+        a == b
+    }
+
+    fn quickcheck_join_graphemes(s: String) -> bool {
+        let a = s.graphemes(true).collect::<String>();
+        let b = s.graphemes(false).collect::<String>();
+        a == s && b == s
+    }
+
+    fn quickcheck_forward_reverse_words(s: String) -> bool {
+        let a = s.split_word_bounds().collect::<Vec<_>>();
+        let mut b = s.split_word_bounds().rev().collect::<Vec<_>>();
+        b.reverse();
+        a == b
+    }
+
+    fn quickcheck_join_words(s: String) -> bool {
+        let a = s.split_word_bounds().collect::<String>();
+        a == s
+    }
+}
diff --git a/rustc_deps/vendor/unicode-segmentation/src/testdata.rs b/rustc_deps/vendor/unicode-segmentation/src/testdata.rs
new file mode 100644
index 0000000..185489e
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/src/testdata.rs
@@ -0,0 +1,2058 @@
+// 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.
+
+// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
+
+#![allow(missing_docs, non_upper_case_globals, non_snake_case)]
+    // official Unicode test data
+    // http://www.unicode.org/Public/UNIDATA/auxiliary/GraphemeBreakTest.txt
+    pub const TEST_SAME: &'static [(&'static str, &'static [&'static str])] = &[
+        ("\u{20}\u{20}", &["\u{20}", "\u{20}"]), ("\u{20}\u{308}\u{20}", &["\u{20}\u{308}",
+        "\u{20}"]), ("\u{20}\u{d}", &["\u{20}", "\u{d}"]), ("\u{20}\u{308}\u{d}", &["\u{20}\u{308}",
+        "\u{d}"]), ("\u{20}\u{a}", &["\u{20}", "\u{a}"]), ("\u{20}\u{308}\u{a}", &["\u{20}\u{308}",
+        "\u{a}"]), ("\u{20}\u{1}", &["\u{20}", "\u{1}"]), ("\u{20}\u{308}\u{1}", &["\u{20}\u{308}",
+        "\u{1}"]), ("\u{20}\u{300}", &["\u{20}\u{300}"]), ("\u{20}\u{308}\u{300}",
+        &["\u{20}\u{308}\u{300}"]), ("\u{20}\u{600}", &["\u{20}", "\u{600}"]),
+        ("\u{20}\u{308}\u{600}", &["\u{20}\u{308}", "\u{600}"]), ("\u{20}\u{1100}", &["\u{20}",
+        "\u{1100}"]), ("\u{20}\u{308}\u{1100}", &["\u{20}\u{308}", "\u{1100}"]), ("\u{20}\u{1160}",
+        &["\u{20}", "\u{1160}"]), ("\u{20}\u{308}\u{1160}", &["\u{20}\u{308}", "\u{1160}"]),
+        ("\u{20}\u{11a8}", &["\u{20}", "\u{11a8}"]), ("\u{20}\u{308}\u{11a8}", &["\u{20}\u{308}",
+        "\u{11a8}"]), ("\u{20}\u{ac00}", &["\u{20}", "\u{ac00}"]), ("\u{20}\u{308}\u{ac00}",
+        &["\u{20}\u{308}", "\u{ac00}"]), ("\u{20}\u{ac01}", &["\u{20}", "\u{ac01}"]),
+        ("\u{20}\u{308}\u{ac01}", &["\u{20}\u{308}", "\u{ac01}"]), ("\u{20}\u{1f1e6}", &["\u{20}",
+        "\u{1f1e6}"]), ("\u{20}\u{308}\u{1f1e6}", &["\u{20}\u{308}", "\u{1f1e6}"]),
+        ("\u{20}\u{261d}", &["\u{20}", "\u{261d}"]), ("\u{20}\u{308}\u{261d}", &["\u{20}\u{308}",
+        "\u{261d}"]), ("\u{20}\u{1f3fb}", &["\u{20}", "\u{1f3fb}"]), ("\u{20}\u{308}\u{1f3fb}",
+        &["\u{20}\u{308}", "\u{1f3fb}"]), ("\u{20}\u{200d}", &["\u{20}\u{200d}"]),
+        ("\u{20}\u{308}\u{200d}", &["\u{20}\u{308}\u{200d}"]), ("\u{20}\u{2764}", &["\u{20}",
+        "\u{2764}"]), ("\u{20}\u{308}\u{2764}", &["\u{20}\u{308}", "\u{2764}"]), ("\u{20}\u{1f466}",
+        &["\u{20}", "\u{1f466}"]), ("\u{20}\u{308}\u{1f466}", &["\u{20}\u{308}", "\u{1f466}"]),
+        ("\u{20}\u{378}", &["\u{20}", "\u{378}"]), ("\u{20}\u{308}\u{378}", &["\u{20}\u{308}",
+        "\u{378}"]), ("\u{d}\u{20}", &["\u{d}", "\u{20}"]), ("\u{d}\u{308}\u{20}", &["\u{d}",
+        "\u{308}", "\u{20}"]), ("\u{d}\u{d}", &["\u{d}", "\u{d}"]), ("\u{d}\u{308}\u{d}", &["\u{d}",
+        "\u{308}", "\u{d}"]), ("\u{d}\u{a}", &["\u{d}\u{a}"]), ("\u{d}\u{308}\u{a}", &["\u{d}",
+        "\u{308}", "\u{a}"]), ("\u{d}\u{1}", &["\u{d}", "\u{1}"]), ("\u{d}\u{308}\u{1}", &["\u{d}",
+        "\u{308}", "\u{1}"]), ("\u{d}\u{300}", &["\u{d}", "\u{300}"]), ("\u{d}\u{308}\u{300}",
+        &["\u{d}", "\u{308}\u{300}"]), ("\u{d}\u{600}", &["\u{d}", "\u{600}"]),
+        ("\u{d}\u{308}\u{600}", &["\u{d}", "\u{308}", "\u{600}"]), ("\u{d}\u{903}", &["\u{d}",
+        "\u{903}"]), ("\u{d}\u{1100}", &["\u{d}", "\u{1100}"]), ("\u{d}\u{308}\u{1100}", &["\u{d}",
+        "\u{308}", "\u{1100}"]), ("\u{d}\u{1160}", &["\u{d}", "\u{1160}"]), ("\u{d}\u{308}\u{1160}",
+        &["\u{d}", "\u{308}", "\u{1160}"]), ("\u{d}\u{11a8}", &["\u{d}", "\u{11a8}"]),
+        ("\u{d}\u{308}\u{11a8}", &["\u{d}", "\u{308}", "\u{11a8}"]), ("\u{d}\u{ac00}", &["\u{d}",
+        "\u{ac00}"]), ("\u{d}\u{308}\u{ac00}", &["\u{d}", "\u{308}", "\u{ac00}"]), ("\u{d}\u{ac01}",
+        &["\u{d}", "\u{ac01}"]), ("\u{d}\u{308}\u{ac01}", &["\u{d}", "\u{308}", "\u{ac01}"]),
+        ("\u{d}\u{1f1e6}", &["\u{d}", "\u{1f1e6}"]), ("\u{d}\u{308}\u{1f1e6}", &["\u{d}", "\u{308}",
+        "\u{1f1e6}"]), ("\u{d}\u{261d}", &["\u{d}", "\u{261d}"]), ("\u{d}\u{308}\u{261d}",
+        &["\u{d}", "\u{308}", "\u{261d}"]), ("\u{d}\u{1f3fb}", &["\u{d}", "\u{1f3fb}"]),
+        ("\u{d}\u{308}\u{1f3fb}", &["\u{d}", "\u{308}", "\u{1f3fb}"]), ("\u{d}\u{200d}", &["\u{d}",
+        "\u{200d}"]), ("\u{d}\u{308}\u{200d}", &["\u{d}", "\u{308}\u{200d}"]), ("\u{d}\u{2764}",
+        &["\u{d}", "\u{2764}"]), ("\u{d}\u{308}\u{2764}", &["\u{d}", "\u{308}", "\u{2764}"]),
+        ("\u{d}\u{1f466}", &["\u{d}", "\u{1f466}"]), ("\u{d}\u{308}\u{1f466}", &["\u{d}", "\u{308}",
+        "\u{1f466}"]), ("\u{d}\u{378}", &["\u{d}", "\u{378}"]), ("\u{d}\u{308}\u{378}", &["\u{d}",
+        "\u{308}", "\u{378}"]), ("\u{a}\u{20}", &["\u{a}", "\u{20}"]), ("\u{a}\u{308}\u{20}",
+        &["\u{a}", "\u{308}", "\u{20}"]), ("\u{a}\u{d}", &["\u{a}", "\u{d}"]), ("\u{a}\u{308}\u{d}",
+        &["\u{a}", "\u{308}", "\u{d}"]), ("\u{a}\u{a}", &["\u{a}", "\u{a}"]), ("\u{a}\u{308}\u{a}",
+        &["\u{a}", "\u{308}", "\u{a}"]), ("\u{a}\u{1}", &["\u{a}", "\u{1}"]), ("\u{a}\u{308}\u{1}",
+        &["\u{a}", "\u{308}", "\u{1}"]), ("\u{a}\u{300}", &["\u{a}", "\u{300}"]),
+        ("\u{a}\u{308}\u{300}", &["\u{a}", "\u{308}\u{300}"]), ("\u{a}\u{600}", &["\u{a}",
+        "\u{600}"]), ("\u{a}\u{308}\u{600}", &["\u{a}", "\u{308}", "\u{600}"]), ("\u{a}\u{903}",
+        &["\u{a}", "\u{903}"]), ("\u{a}\u{1100}", &["\u{a}", "\u{1100}"]), ("\u{a}\u{308}\u{1100}",
+        &["\u{a}", "\u{308}", "\u{1100}"]), ("\u{a}\u{1160}", &["\u{a}", "\u{1160}"]),
+        ("\u{a}\u{308}\u{1160}", &["\u{a}", "\u{308}", "\u{1160}"]), ("\u{a}\u{11a8}", &["\u{a}",
+        "\u{11a8}"]), ("\u{a}\u{308}\u{11a8}", &["\u{a}", "\u{308}", "\u{11a8}"]), ("\u{a}\u{ac00}",
+        &["\u{a}", "\u{ac00}"]), ("\u{a}\u{308}\u{ac00}", &["\u{a}", "\u{308}", "\u{ac00}"]),
+        ("\u{a}\u{ac01}", &["\u{a}", "\u{ac01}"]), ("\u{a}\u{308}\u{ac01}", &["\u{a}", "\u{308}",
+        "\u{ac01}"]), ("\u{a}\u{1f1e6}", &["\u{a}", "\u{1f1e6}"]), ("\u{a}\u{308}\u{1f1e6}",
+        &["\u{a}", "\u{308}", "\u{1f1e6}"]), ("\u{a}\u{261d}", &["\u{a}", "\u{261d}"]),
+        ("\u{a}\u{308}\u{261d}", &["\u{a}", "\u{308}", "\u{261d}"]), ("\u{a}\u{1f3fb}", &["\u{a}",
+        "\u{1f3fb}"]), ("\u{a}\u{308}\u{1f3fb}", &["\u{a}", "\u{308}", "\u{1f3fb}"]),
+        ("\u{a}\u{200d}", &["\u{a}", "\u{200d}"]), ("\u{a}\u{308}\u{200d}", &["\u{a}",
+        "\u{308}\u{200d}"]), ("\u{a}\u{2764}", &["\u{a}", "\u{2764}"]), ("\u{a}\u{308}\u{2764}",
+        &["\u{a}", "\u{308}", "\u{2764}"]), ("\u{a}\u{1f466}", &["\u{a}", "\u{1f466}"]),
+        ("\u{a}\u{308}\u{1f466}", &["\u{a}", "\u{308}", "\u{1f466}"]), ("\u{a}\u{378}", &["\u{a}",
+        "\u{378}"]), ("\u{a}\u{308}\u{378}", &["\u{a}", "\u{308}", "\u{378}"]), ("\u{1}\u{20}",
+        &["\u{1}", "\u{20}"]), ("\u{1}\u{308}\u{20}", &["\u{1}", "\u{308}", "\u{20}"]),
+        ("\u{1}\u{d}", &["\u{1}", "\u{d}"]), ("\u{1}\u{308}\u{d}", &["\u{1}", "\u{308}", "\u{d}"]),
+        ("\u{1}\u{a}", &["\u{1}", "\u{a}"]), ("\u{1}\u{308}\u{a}", &["\u{1}", "\u{308}", "\u{a}"]),
+        ("\u{1}\u{1}", &["\u{1}", "\u{1}"]), ("\u{1}\u{308}\u{1}", &["\u{1}", "\u{308}", "\u{1}"]),
+        ("\u{1}\u{300}", &["\u{1}", "\u{300}"]), ("\u{1}\u{308}\u{300}", &["\u{1}",
+        "\u{308}\u{300}"]), ("\u{1}\u{600}", &["\u{1}", "\u{600}"]), ("\u{1}\u{308}\u{600}",
+        &["\u{1}", "\u{308}", "\u{600}"]), ("\u{1}\u{903}", &["\u{1}", "\u{903}"]),
+        ("\u{1}\u{1100}", &["\u{1}", "\u{1100}"]), ("\u{1}\u{308}\u{1100}", &["\u{1}", "\u{308}",
+        "\u{1100}"]), ("\u{1}\u{1160}", &["\u{1}", "\u{1160}"]), ("\u{1}\u{308}\u{1160}", &["\u{1}",
+        "\u{308}", "\u{1160}"]), ("\u{1}\u{11a8}", &["\u{1}", "\u{11a8}"]), ("\u{1}\u{308}\u{11a8}",
+        &["\u{1}", "\u{308}", "\u{11a8}"]), ("\u{1}\u{ac00}", &["\u{1}", "\u{ac00}"]),
+        ("\u{1}\u{308}\u{ac00}", &["\u{1}", "\u{308}", "\u{ac00}"]), ("\u{1}\u{ac01}", &["\u{1}",
+        "\u{ac01}"]), ("\u{1}\u{308}\u{ac01}", &["\u{1}", "\u{308}", "\u{ac01}"]),
+        ("\u{1}\u{1f1e6}", &["\u{1}", "\u{1f1e6}"]), ("\u{1}\u{308}\u{1f1e6}", &["\u{1}", "\u{308}",
+        "\u{1f1e6}"]), ("\u{1}\u{261d}", &["\u{1}", "\u{261d}"]), ("\u{1}\u{308}\u{261d}",
+        &["\u{1}", "\u{308}", "\u{261d}"]), ("\u{1}\u{1f3fb}", &["\u{1}", "\u{1f3fb}"]),
+        ("\u{1}\u{308}\u{1f3fb}", &["\u{1}", "\u{308}", "\u{1f3fb}"]), ("\u{1}\u{200d}", &["\u{1}",
+        "\u{200d}"]), ("\u{1}\u{308}\u{200d}", &["\u{1}", "\u{308}\u{200d}"]), ("\u{1}\u{2764}",
+        &["\u{1}", "\u{2764}"]), ("\u{1}\u{308}\u{2764}", &["\u{1}", "\u{308}", "\u{2764}"]),
+        ("\u{1}\u{1f466}", &["\u{1}", "\u{1f466}"]), ("\u{1}\u{308}\u{1f466}", &["\u{1}", "\u{308}",
+        "\u{1f466}"]), ("\u{1}\u{378}", &["\u{1}", "\u{378}"]), ("\u{1}\u{308}\u{378}", &["\u{1}",
+        "\u{308}", "\u{378}"]), ("\u{300}\u{20}", &["\u{300}", "\u{20}"]), ("\u{300}\u{308}\u{20}",
+        &["\u{300}\u{308}", "\u{20}"]), ("\u{300}\u{d}", &["\u{300}", "\u{d}"]),
+        ("\u{300}\u{308}\u{d}", &["\u{300}\u{308}", "\u{d}"]), ("\u{300}\u{a}", &["\u{300}",
+        "\u{a}"]), ("\u{300}\u{308}\u{a}", &["\u{300}\u{308}", "\u{a}"]), ("\u{300}\u{1}",
+        &["\u{300}", "\u{1}"]), ("\u{300}\u{308}\u{1}", &["\u{300}\u{308}", "\u{1}"]),
+        ("\u{300}\u{300}", &["\u{300}\u{300}"]), ("\u{300}\u{308}\u{300}",
+        &["\u{300}\u{308}\u{300}"]), ("\u{300}\u{600}", &["\u{300}", "\u{600}"]),
+        ("\u{300}\u{308}\u{600}", &["\u{300}\u{308}", "\u{600}"]), ("\u{300}\u{1100}", &["\u{300}",
+        "\u{1100}"]), ("\u{300}\u{308}\u{1100}", &["\u{300}\u{308}", "\u{1100}"]),
+        ("\u{300}\u{1160}", &["\u{300}", "\u{1160}"]), ("\u{300}\u{308}\u{1160}",
+        &["\u{300}\u{308}", "\u{1160}"]), ("\u{300}\u{11a8}", &["\u{300}", "\u{11a8}"]),
+        ("\u{300}\u{308}\u{11a8}", &["\u{300}\u{308}", "\u{11a8}"]), ("\u{300}\u{ac00}",
+        &["\u{300}", "\u{ac00}"]), ("\u{300}\u{308}\u{ac00}", &["\u{300}\u{308}", "\u{ac00}"]),
+        ("\u{300}\u{ac01}", &["\u{300}", "\u{ac01}"]), ("\u{300}\u{308}\u{ac01}",
+        &["\u{300}\u{308}", "\u{ac01}"]), ("\u{300}\u{1f1e6}", &["\u{300}", "\u{1f1e6}"]),
+        ("\u{300}\u{308}\u{1f1e6}", &["\u{300}\u{308}", "\u{1f1e6}"]), ("\u{300}\u{261d}",
+        &["\u{300}", "\u{261d}"]), ("\u{300}\u{308}\u{261d}", &["\u{300}\u{308}", "\u{261d}"]),
+        ("\u{300}\u{1f3fb}", &["\u{300}", "\u{1f3fb}"]), ("\u{300}\u{308}\u{1f3fb}",
+        &["\u{300}\u{308}", "\u{1f3fb}"]), ("\u{300}\u{200d}", &["\u{300}\u{200d}"]),
+        ("\u{300}\u{308}\u{200d}", &["\u{300}\u{308}\u{200d}"]), ("\u{300}\u{2764}", &["\u{300}",
+        "\u{2764}"]), ("\u{300}\u{308}\u{2764}", &["\u{300}\u{308}", "\u{2764}"]),
+        ("\u{300}\u{1f466}", &["\u{300}", "\u{1f466}"]), ("\u{300}\u{308}\u{1f466}",
+        &["\u{300}\u{308}", "\u{1f466}"]), ("\u{300}\u{378}", &["\u{300}", "\u{378}"]),
+        ("\u{300}\u{308}\u{378}", &["\u{300}\u{308}", "\u{378}"]), ("\u{600}\u{308}\u{20}",
+        &["\u{600}\u{308}", "\u{20}"]), ("\u{600}\u{d}", &["\u{600}", "\u{d}"]),
+        ("\u{600}\u{308}\u{d}", &["\u{600}\u{308}", "\u{d}"]), ("\u{600}\u{a}", &["\u{600}",
+        "\u{a}"]), ("\u{600}\u{308}\u{a}", &["\u{600}\u{308}", "\u{a}"]), ("\u{600}\u{1}",
+        &["\u{600}", "\u{1}"]), ("\u{600}\u{308}\u{1}", &["\u{600}\u{308}", "\u{1}"]),
+        ("\u{600}\u{300}", &["\u{600}\u{300}"]), ("\u{600}\u{308}\u{300}",
+        &["\u{600}\u{308}\u{300}"]), ("\u{600}\u{308}\u{600}", &["\u{600}\u{308}", "\u{600}"]),
+        ("\u{600}\u{308}\u{1100}", &["\u{600}\u{308}", "\u{1100}"]), ("\u{600}\u{308}\u{1160}",
+        &["\u{600}\u{308}", "\u{1160}"]), ("\u{600}\u{308}\u{11a8}", &["\u{600}\u{308}",
+        "\u{11a8}"]), ("\u{600}\u{308}\u{ac00}", &["\u{600}\u{308}", "\u{ac00}"]),
+        ("\u{600}\u{308}\u{ac01}", &["\u{600}\u{308}", "\u{ac01}"]), ("\u{600}\u{308}\u{1f1e6}",
+        &["\u{600}\u{308}", "\u{1f1e6}"]), ("\u{600}\u{308}\u{261d}", &["\u{600}\u{308}",
+        "\u{261d}"]), ("\u{600}\u{308}\u{1f3fb}", &["\u{600}\u{308}", "\u{1f3fb}"]),
+        ("\u{600}\u{200d}", &["\u{600}\u{200d}"]), ("\u{600}\u{308}\u{200d}",
+        &["\u{600}\u{308}\u{200d}"]), ("\u{600}\u{308}\u{2764}", &["\u{600}\u{308}", "\u{2764}"]),
+        ("\u{600}\u{308}\u{1f466}", &["\u{600}\u{308}", "\u{1f466}"]), ("\u{600}\u{308}\u{378}",
+        &["\u{600}\u{308}", "\u{378}"]), ("\u{903}\u{20}", &["\u{903}", "\u{20}"]),
+        ("\u{903}\u{308}\u{20}", &["\u{903}\u{308}", "\u{20}"]), ("\u{903}\u{d}", &["\u{903}",
+        "\u{d}"]), ("\u{903}\u{308}\u{d}", &["\u{903}\u{308}", "\u{d}"]), ("\u{903}\u{a}",
+        &["\u{903}", "\u{a}"]), ("\u{903}\u{308}\u{a}", &["\u{903}\u{308}", "\u{a}"]),
+        ("\u{903}\u{1}", &["\u{903}", "\u{1}"]), ("\u{903}\u{308}\u{1}", &["\u{903}\u{308}",
+        "\u{1}"]), ("\u{903}\u{300}", &["\u{903}\u{300}"]), ("\u{903}\u{308}\u{300}",
+        &["\u{903}\u{308}\u{300}"]), ("\u{903}\u{600}", &["\u{903}", "\u{600}"]),
+        ("\u{903}\u{308}\u{600}", &["\u{903}\u{308}", "\u{600}"]), ("\u{903}\u{1100}", &["\u{903}",
+        "\u{1100}"]), ("\u{903}\u{308}\u{1100}", &["\u{903}\u{308}", "\u{1100}"]),
+        ("\u{903}\u{1160}", &["\u{903}", "\u{1160}"]), ("\u{903}\u{308}\u{1160}",
+        &["\u{903}\u{308}", "\u{1160}"]), ("\u{903}\u{11a8}", &["\u{903}", "\u{11a8}"]),
+        ("\u{903}\u{308}\u{11a8}", &["\u{903}\u{308}", "\u{11a8}"]), ("\u{903}\u{ac00}",
+        &["\u{903}", "\u{ac00}"]), ("\u{903}\u{308}\u{ac00}", &["\u{903}\u{308}", "\u{ac00}"]),
+        ("\u{903}\u{ac01}", &["\u{903}", "\u{ac01}"]), ("\u{903}\u{308}\u{ac01}",
+        &["\u{903}\u{308}", "\u{ac01}"]), ("\u{903}\u{1f1e6}", &["\u{903}", "\u{1f1e6}"]),
+        ("\u{903}\u{308}\u{1f1e6}", &["\u{903}\u{308}", "\u{1f1e6}"]), ("\u{903}\u{261d}",
+        &["\u{903}", "\u{261d}"]), ("\u{903}\u{308}\u{261d}", &["\u{903}\u{308}", "\u{261d}"]),
+        ("\u{903}\u{1f3fb}", &["\u{903}", "\u{1f3fb}"]), ("\u{903}\u{308}\u{1f3fb}",
+        &["\u{903}\u{308}", "\u{1f3fb}"]), ("\u{903}\u{200d}", &["\u{903}\u{200d}"]),
+        ("\u{903}\u{308}\u{200d}", &["\u{903}\u{308}\u{200d}"]), ("\u{903}\u{2764}", &["\u{903}",
+        "\u{2764}"]), ("\u{903}\u{308}\u{2764}", &["\u{903}\u{308}", "\u{2764}"]),
+        ("\u{903}\u{1f466}", &["\u{903}", "\u{1f466}"]), ("\u{903}\u{308}\u{1f466}",
+        &["\u{903}\u{308}", "\u{1f466}"]), ("\u{903}\u{378}", &["\u{903}", "\u{378}"]),
+        ("\u{903}\u{308}\u{378}", &["\u{903}\u{308}", "\u{378}"]), ("\u{1100}\u{20}", &["\u{1100}",
+        "\u{20}"]), ("\u{1100}\u{308}\u{20}", &["\u{1100}\u{308}", "\u{20}"]), ("\u{1100}\u{d}",
+        &["\u{1100}", "\u{d}"]), ("\u{1100}\u{308}\u{d}", &["\u{1100}\u{308}", "\u{d}"]),
+        ("\u{1100}\u{a}", &["\u{1100}", "\u{a}"]), ("\u{1100}\u{308}\u{a}", &["\u{1100}\u{308}",
+        "\u{a}"]), ("\u{1100}\u{1}", &["\u{1100}", "\u{1}"]), ("\u{1100}\u{308}\u{1}",
+        &["\u{1100}\u{308}", "\u{1}"]), ("\u{1100}\u{300}", &["\u{1100}\u{300}"]),
+        ("\u{1100}\u{308}\u{300}", &["\u{1100}\u{308}\u{300}"]), ("\u{1100}\u{600}", &["\u{1100}",
+        "\u{600}"]), ("\u{1100}\u{308}\u{600}", &["\u{1100}\u{308}", "\u{600}"]),
+        ("\u{1100}\u{1100}", &["\u{1100}\u{1100}"]), ("\u{1100}\u{308}\u{1100}",
+        &["\u{1100}\u{308}", "\u{1100}"]), ("\u{1100}\u{1160}", &["\u{1100}\u{1160}"]),
+        ("\u{1100}\u{308}\u{1160}", &["\u{1100}\u{308}", "\u{1160}"]), ("\u{1100}\u{11a8}",
+        &["\u{1100}", "\u{11a8}"]), ("\u{1100}\u{308}\u{11a8}", &["\u{1100}\u{308}", "\u{11a8}"]),
+        ("\u{1100}\u{ac00}", &["\u{1100}\u{ac00}"]), ("\u{1100}\u{308}\u{ac00}",
+        &["\u{1100}\u{308}", "\u{ac00}"]), ("\u{1100}\u{ac01}", &["\u{1100}\u{ac01}"]),
+        ("\u{1100}\u{308}\u{ac01}", &["\u{1100}\u{308}", "\u{ac01}"]), ("\u{1100}\u{1f1e6}",
+        &["\u{1100}", "\u{1f1e6}"]), ("\u{1100}\u{308}\u{1f1e6}", &["\u{1100}\u{308}",
+        "\u{1f1e6}"]), ("\u{1100}\u{261d}", &["\u{1100}", "\u{261d}"]), ("\u{1100}\u{308}\u{261d}",
+        &["\u{1100}\u{308}", "\u{261d}"]), ("\u{1100}\u{1f3fb}", &["\u{1100}", "\u{1f3fb}"]),
+        ("\u{1100}\u{308}\u{1f3fb}", &["\u{1100}\u{308}", "\u{1f3fb}"]), ("\u{1100}\u{200d}",
+        &["\u{1100}\u{200d}"]), ("\u{1100}\u{308}\u{200d}", &["\u{1100}\u{308}\u{200d}"]),
+        ("\u{1100}\u{2764}", &["\u{1100}", "\u{2764}"]), ("\u{1100}\u{308}\u{2764}",
+        &["\u{1100}\u{308}", "\u{2764}"]), ("\u{1100}\u{1f466}", &["\u{1100}", "\u{1f466}"]),
+        ("\u{1100}\u{308}\u{1f466}", &["\u{1100}\u{308}", "\u{1f466}"]), ("\u{1100}\u{378}",
+        &["\u{1100}", "\u{378}"]), ("\u{1100}\u{308}\u{378}", &["\u{1100}\u{308}", "\u{378}"]),
+        ("\u{1160}\u{20}", &["\u{1160}", "\u{20}"]), ("\u{1160}\u{308}\u{20}", &["\u{1160}\u{308}",
+        "\u{20}"]), ("\u{1160}\u{d}", &["\u{1160}", "\u{d}"]), ("\u{1160}\u{308}\u{d}",
+        &["\u{1160}\u{308}", "\u{d}"]), ("\u{1160}\u{a}", &["\u{1160}", "\u{a}"]),
+        ("\u{1160}\u{308}\u{a}", &["\u{1160}\u{308}", "\u{a}"]), ("\u{1160}\u{1}", &["\u{1160}",
+        "\u{1}"]), ("\u{1160}\u{308}\u{1}", &["\u{1160}\u{308}", "\u{1}"]), ("\u{1160}\u{300}",
+        &["\u{1160}\u{300}"]), ("\u{1160}\u{308}\u{300}", &["\u{1160}\u{308}\u{300}"]),
+        ("\u{1160}\u{600}", &["\u{1160}", "\u{600}"]), ("\u{1160}\u{308}\u{600}",
+        &["\u{1160}\u{308}", "\u{600}"]), ("\u{1160}\u{1100}", &["\u{1160}", "\u{1100}"]),
+        ("\u{1160}\u{308}\u{1100}", &["\u{1160}\u{308}", "\u{1100}"]), ("\u{1160}\u{1160}",
+        &["\u{1160}\u{1160}"]), ("\u{1160}\u{308}\u{1160}", &["\u{1160}\u{308}", "\u{1160}"]),
+        ("\u{1160}\u{11a8}", &["\u{1160}\u{11a8}"]), ("\u{1160}\u{308}\u{11a8}",
+        &["\u{1160}\u{308}", "\u{11a8}"]), ("\u{1160}\u{ac00}", &["\u{1160}", "\u{ac00}"]),
+        ("\u{1160}\u{308}\u{ac00}", &["\u{1160}\u{308}", "\u{ac00}"]), ("\u{1160}\u{ac01}",
+        &["\u{1160}", "\u{ac01}"]), ("\u{1160}\u{308}\u{ac01}", &["\u{1160}\u{308}", "\u{ac01}"]),
+        ("\u{1160}\u{1f1e6}", &["\u{1160}", "\u{1f1e6}"]), ("\u{1160}\u{308}\u{1f1e6}",
+        &["\u{1160}\u{308}", "\u{1f1e6}"]), ("\u{1160}\u{261d}", &["\u{1160}", "\u{261d}"]),
+        ("\u{1160}\u{308}\u{261d}", &["\u{1160}\u{308}", "\u{261d}"]), ("\u{1160}\u{1f3fb}",
+        &["\u{1160}", "\u{1f3fb}"]), ("\u{1160}\u{308}\u{1f3fb}", &["\u{1160}\u{308}",
+        "\u{1f3fb}"]), ("\u{1160}\u{200d}", &["\u{1160}\u{200d}"]), ("\u{1160}\u{308}\u{200d}",
+        &["\u{1160}\u{308}\u{200d}"]), ("\u{1160}\u{2764}", &["\u{1160}", "\u{2764}"]),
+        ("\u{1160}\u{308}\u{2764}", &["\u{1160}\u{308}", "\u{2764}"]), ("\u{1160}\u{1f466}",
+        &["\u{1160}", "\u{1f466}"]), ("\u{1160}\u{308}\u{1f466}", &["\u{1160}\u{308}",
+        "\u{1f466}"]), ("\u{1160}\u{378}", &["\u{1160}", "\u{378}"]), ("\u{1160}\u{308}\u{378}",
+        &["\u{1160}\u{308}", "\u{378}"]), ("\u{11a8}\u{20}", &["\u{11a8}", "\u{20}"]),
+        ("\u{11a8}\u{308}\u{20}", &["\u{11a8}\u{308}", "\u{20}"]), ("\u{11a8}\u{d}", &["\u{11a8}",
+        "\u{d}"]), ("\u{11a8}\u{308}\u{d}", &["\u{11a8}\u{308}", "\u{d}"]), ("\u{11a8}\u{a}",
+        &["\u{11a8}", "\u{a}"]), ("\u{11a8}\u{308}\u{a}", &["\u{11a8}\u{308}", "\u{a}"]),
+        ("\u{11a8}\u{1}", &["\u{11a8}", "\u{1}"]), ("\u{11a8}\u{308}\u{1}", &["\u{11a8}\u{308}",
+        "\u{1}"]), ("\u{11a8}\u{300}", &["\u{11a8}\u{300}"]), ("\u{11a8}\u{308}\u{300}",
+        &["\u{11a8}\u{308}\u{300}"]), ("\u{11a8}\u{600}", &["\u{11a8}", "\u{600}"]),
+        ("\u{11a8}\u{308}\u{600}", &["\u{11a8}\u{308}", "\u{600}"]), ("\u{11a8}\u{1100}",
+        &["\u{11a8}", "\u{1100}"]), ("\u{11a8}\u{308}\u{1100}", &["\u{11a8}\u{308}", "\u{1100}"]),
+        ("\u{11a8}\u{1160}", &["\u{11a8}", "\u{1160}"]), ("\u{11a8}\u{308}\u{1160}",
+        &["\u{11a8}\u{308}", "\u{1160}"]), ("\u{11a8}\u{11a8}", &["\u{11a8}\u{11a8}"]),
+        ("\u{11a8}\u{308}\u{11a8}", &["\u{11a8}\u{308}", "\u{11a8}"]), ("\u{11a8}\u{ac00}",
+        &["\u{11a8}", "\u{ac00}"]), ("\u{11a8}\u{308}\u{ac00}", &["\u{11a8}\u{308}", "\u{ac00}"]),
+        ("\u{11a8}\u{ac01}", &["\u{11a8}", "\u{ac01}"]), ("\u{11a8}\u{308}\u{ac01}",
+        &["\u{11a8}\u{308}", "\u{ac01}"]), ("\u{11a8}\u{1f1e6}", &["\u{11a8}", "\u{1f1e6}"]),
+        ("\u{11a8}\u{308}\u{1f1e6}", &["\u{11a8}\u{308}", "\u{1f1e6}"]), ("\u{11a8}\u{261d}",
+        &["\u{11a8}", "\u{261d}"]), ("\u{11a8}\u{308}\u{261d}", &["\u{11a8}\u{308}", "\u{261d}"]),
+        ("\u{11a8}\u{1f3fb}", &["\u{11a8}", "\u{1f3fb}"]), ("\u{11a8}\u{308}\u{1f3fb}",
+        &["\u{11a8}\u{308}", "\u{1f3fb}"]), ("\u{11a8}\u{200d}", &["\u{11a8}\u{200d}"]),
+        ("\u{11a8}\u{308}\u{200d}", &["\u{11a8}\u{308}\u{200d}"]), ("\u{11a8}\u{2764}",
+        &["\u{11a8}", "\u{2764}"]), ("\u{11a8}\u{308}\u{2764}", &["\u{11a8}\u{308}", "\u{2764}"]),
+        ("\u{11a8}\u{1f466}", &["\u{11a8}", "\u{1f466}"]), ("\u{11a8}\u{308}\u{1f466}",
+        &["\u{11a8}\u{308}", "\u{1f466}"]), ("\u{11a8}\u{378}", &["\u{11a8}", "\u{378}"]),
+        ("\u{11a8}\u{308}\u{378}", &["\u{11a8}\u{308}", "\u{378}"]), ("\u{ac00}\u{20}",
+        &["\u{ac00}", "\u{20}"]), ("\u{ac00}\u{308}\u{20}", &["\u{ac00}\u{308}", "\u{20}"]),
+        ("\u{ac00}\u{d}", &["\u{ac00}", "\u{d}"]), ("\u{ac00}\u{308}\u{d}", &["\u{ac00}\u{308}",
+        "\u{d}"]), ("\u{ac00}\u{a}", &["\u{ac00}", "\u{a}"]), ("\u{ac00}\u{308}\u{a}",
+        &["\u{ac00}\u{308}", "\u{a}"]), ("\u{ac00}\u{1}", &["\u{ac00}", "\u{1}"]),
+        ("\u{ac00}\u{308}\u{1}", &["\u{ac00}\u{308}", "\u{1}"]), ("\u{ac00}\u{300}",
+        &["\u{ac00}\u{300}"]), ("\u{ac00}\u{308}\u{300}", &["\u{ac00}\u{308}\u{300}"]),
+        ("\u{ac00}\u{600}", &["\u{ac00}", "\u{600}"]), ("\u{ac00}\u{308}\u{600}",
+        &["\u{ac00}\u{308}", "\u{600}"]), ("\u{ac00}\u{1100}", &["\u{ac00}", "\u{1100}"]),
+        ("\u{ac00}\u{308}\u{1100}", &["\u{ac00}\u{308}", "\u{1100}"]), ("\u{ac00}\u{1160}",
+        &["\u{ac00}\u{1160}"]), ("\u{ac00}\u{308}\u{1160}", &["\u{ac00}\u{308}", "\u{1160}"]),
+        ("\u{ac00}\u{11a8}", &["\u{ac00}\u{11a8}"]), ("\u{ac00}\u{308}\u{11a8}",
+        &["\u{ac00}\u{308}", "\u{11a8}"]), ("\u{ac00}\u{ac00}", &["\u{ac00}", "\u{ac00}"]),
+        ("\u{ac00}\u{308}\u{ac00}", &["\u{ac00}\u{308}", "\u{ac00}"]), ("\u{ac00}\u{ac01}",
+        &["\u{ac00}", "\u{ac01}"]), ("\u{ac00}\u{308}\u{ac01}", &["\u{ac00}\u{308}", "\u{ac01}"]),
+        ("\u{ac00}\u{1f1e6}", &["\u{ac00}", "\u{1f1e6}"]), ("\u{ac00}\u{308}\u{1f1e6}",
+        &["\u{ac00}\u{308}", "\u{1f1e6}"]), ("\u{ac00}\u{261d}", &["\u{ac00}", "\u{261d}"]),
+        ("\u{ac00}\u{308}\u{261d}", &["\u{ac00}\u{308}", "\u{261d}"]), ("\u{ac00}\u{1f3fb}",
+        &["\u{ac00}", "\u{1f3fb}"]), ("\u{ac00}\u{308}\u{1f3fb}", &["\u{ac00}\u{308}",
+        "\u{1f3fb}"]), ("\u{ac00}\u{200d}", &["\u{ac00}\u{200d}"]), ("\u{ac00}\u{308}\u{200d}",
+        &["\u{ac00}\u{308}\u{200d}"]), ("\u{ac00}\u{2764}", &["\u{ac00}", "\u{2764}"]),
+        ("\u{ac00}\u{308}\u{2764}", &["\u{ac00}\u{308}", "\u{2764}"]), ("\u{ac00}\u{1f466}",
+        &["\u{ac00}", "\u{1f466}"]), ("\u{ac00}\u{308}\u{1f466}", &["\u{ac00}\u{308}",
+        "\u{1f466}"]), ("\u{ac00}\u{378}", &["\u{ac00}", "\u{378}"]), ("\u{ac00}\u{308}\u{378}",
+        &["\u{ac00}\u{308}", "\u{378}"]), ("\u{ac01}\u{20}", &["\u{ac01}", "\u{20}"]),
+        ("\u{ac01}\u{308}\u{20}", &["\u{ac01}\u{308}", "\u{20}"]), ("\u{ac01}\u{d}", &["\u{ac01}",
+        "\u{d}"]), ("\u{ac01}\u{308}\u{d}", &["\u{ac01}\u{308}", "\u{d}"]), ("\u{ac01}\u{a}",
+        &["\u{ac01}", "\u{a}"]), ("\u{ac01}\u{308}\u{a}", &["\u{ac01}\u{308}", "\u{a}"]),
+        ("\u{ac01}\u{1}", &["\u{ac01}", "\u{1}"]), ("\u{ac01}\u{308}\u{1}", &["\u{ac01}\u{308}",
+        "\u{1}"]), ("\u{ac01}\u{300}", &["\u{ac01}\u{300}"]), ("\u{ac01}\u{308}\u{300}",
+        &["\u{ac01}\u{308}\u{300}"]), ("\u{ac01}\u{600}", &["\u{ac01}", "\u{600}"]),
+        ("\u{ac01}\u{308}\u{600}", &["\u{ac01}\u{308}", "\u{600}"]), ("\u{ac01}\u{1100}",
+        &["\u{ac01}", "\u{1100}"]), ("\u{ac01}\u{308}\u{1100}", &["\u{ac01}\u{308}", "\u{1100}"]),
+        ("\u{ac01}\u{1160}", &["\u{ac01}", "\u{1160}"]), ("\u{ac01}\u{308}\u{1160}",
+        &["\u{ac01}\u{308}", "\u{1160}"]), ("\u{ac01}\u{11a8}", &["\u{ac01}\u{11a8}"]),
+        ("\u{ac01}\u{308}\u{11a8}", &["\u{ac01}\u{308}", "\u{11a8}"]), ("\u{ac01}\u{ac00}",
+        &["\u{ac01}", "\u{ac00}"]), ("\u{ac01}\u{308}\u{ac00}", &["\u{ac01}\u{308}", "\u{ac00}"]),
+        ("\u{ac01}\u{ac01}", &["\u{ac01}", "\u{ac01}"]), ("\u{ac01}\u{308}\u{ac01}",
+        &["\u{ac01}\u{308}", "\u{ac01}"]), ("\u{ac01}\u{1f1e6}", &["\u{ac01}", "\u{1f1e6}"]),
+        ("\u{ac01}\u{308}\u{1f1e6}", &["\u{ac01}\u{308}", "\u{1f1e6}"]), ("\u{ac01}\u{261d}",
+        &["\u{ac01}", "\u{261d}"]), ("\u{ac01}\u{308}\u{261d}", &["\u{ac01}\u{308}", "\u{261d}"]),
+        ("\u{ac01}\u{1f3fb}", &["\u{ac01}", "\u{1f3fb}"]), ("\u{ac01}\u{308}\u{1f3fb}",
+        &["\u{ac01}\u{308}", "\u{1f3fb}"]), ("\u{ac01}\u{200d}", &["\u{ac01}\u{200d}"]),
+        ("\u{ac01}\u{308}\u{200d}", &["\u{ac01}\u{308}\u{200d}"]), ("\u{ac01}\u{2764}",
+        &["\u{ac01}", "\u{2764}"]), ("\u{ac01}\u{308}\u{2764}", &["\u{ac01}\u{308}", "\u{2764}"]),
+        ("\u{ac01}\u{1f466}", &["\u{ac01}", "\u{1f466}"]), ("\u{ac01}\u{308}\u{1f466}",
+        &["\u{ac01}\u{308}", "\u{1f466}"]), ("\u{ac01}\u{378}", &["\u{ac01}", "\u{378}"]),
+        ("\u{ac01}\u{308}\u{378}", &["\u{ac01}\u{308}", "\u{378}"]), ("\u{1f1e6}\u{20}",
+        &["\u{1f1e6}", "\u{20}"]), ("\u{1f1e6}\u{308}\u{20}", &["\u{1f1e6}\u{308}", "\u{20}"]),
+        ("\u{1f1e6}\u{d}", &["\u{1f1e6}", "\u{d}"]), ("\u{1f1e6}\u{308}\u{d}", &["\u{1f1e6}\u{308}",
+        "\u{d}"]), ("\u{1f1e6}\u{a}", &["\u{1f1e6}", "\u{a}"]), ("\u{1f1e6}\u{308}\u{a}",
+        &["\u{1f1e6}\u{308}", "\u{a}"]), ("\u{1f1e6}\u{1}", &["\u{1f1e6}", "\u{1}"]),
+        ("\u{1f1e6}\u{308}\u{1}", &["\u{1f1e6}\u{308}", "\u{1}"]), ("\u{1f1e6}\u{300}",
+        &["\u{1f1e6}\u{300}"]), ("\u{1f1e6}\u{308}\u{300}", &["\u{1f1e6}\u{308}\u{300}"]),
+        ("\u{1f1e6}\u{600}", &["\u{1f1e6}", "\u{600}"]), ("\u{1f1e6}\u{308}\u{600}",
+        &["\u{1f1e6}\u{308}", "\u{600}"]), ("\u{1f1e6}\u{1100}", &["\u{1f1e6}", "\u{1100}"]),
+        ("\u{1f1e6}\u{308}\u{1100}", &["\u{1f1e6}\u{308}", "\u{1100}"]), ("\u{1f1e6}\u{1160}",
+        &["\u{1f1e6}", "\u{1160}"]), ("\u{1f1e6}\u{308}\u{1160}", &["\u{1f1e6}\u{308}",
+        "\u{1160}"]), ("\u{1f1e6}\u{11a8}", &["\u{1f1e6}", "\u{11a8}"]),
+        ("\u{1f1e6}\u{308}\u{11a8}", &["\u{1f1e6}\u{308}", "\u{11a8}"]), ("\u{1f1e6}\u{ac00}",
+        &["\u{1f1e6}", "\u{ac00}"]), ("\u{1f1e6}\u{308}\u{ac00}", &["\u{1f1e6}\u{308}",
+        "\u{ac00}"]), ("\u{1f1e6}\u{ac01}", &["\u{1f1e6}", "\u{ac01}"]),
+        ("\u{1f1e6}\u{308}\u{ac01}", &["\u{1f1e6}\u{308}", "\u{ac01}"]), ("\u{1f1e6}\u{1f1e6}",
+        &["\u{1f1e6}\u{1f1e6}"]), ("\u{1f1e6}\u{308}\u{1f1e6}", &["\u{1f1e6}\u{308}", "\u{1f1e6}"]),
+        ("\u{1f1e6}\u{261d}", &["\u{1f1e6}", "\u{261d}"]), ("\u{1f1e6}\u{308}\u{261d}",
+        &["\u{1f1e6}\u{308}", "\u{261d}"]), ("\u{1f1e6}\u{1f3fb}", &["\u{1f1e6}", "\u{1f3fb}"]),
+        ("\u{1f1e6}\u{308}\u{1f3fb}", &["\u{1f1e6}\u{308}", "\u{1f3fb}"]), ("\u{1f1e6}\u{200d}",
+        &["\u{1f1e6}\u{200d}"]), ("\u{1f1e6}\u{308}\u{200d}", &["\u{1f1e6}\u{308}\u{200d}"]),
+        ("\u{1f1e6}\u{2764}", &["\u{1f1e6}", "\u{2764}"]), ("\u{1f1e6}\u{308}\u{2764}",
+        &["\u{1f1e6}\u{308}", "\u{2764}"]), ("\u{1f1e6}\u{1f466}", &["\u{1f1e6}", "\u{1f466}"]),
+        ("\u{1f1e6}\u{308}\u{1f466}", &["\u{1f1e6}\u{308}", "\u{1f466}"]), ("\u{1f1e6}\u{378}",
+        &["\u{1f1e6}", "\u{378}"]), ("\u{1f1e6}\u{308}\u{378}", &["\u{1f1e6}\u{308}", "\u{378}"]),
+        ("\u{261d}\u{20}", &["\u{261d}", "\u{20}"]), ("\u{261d}\u{308}\u{20}", &["\u{261d}\u{308}",
+        "\u{20}"]), ("\u{261d}\u{d}", &["\u{261d}", "\u{d}"]), ("\u{261d}\u{308}\u{d}",
+        &["\u{261d}\u{308}", "\u{d}"]), ("\u{261d}\u{a}", &["\u{261d}", "\u{a}"]),
+        ("\u{261d}\u{308}\u{a}", &["\u{261d}\u{308}", "\u{a}"]), ("\u{261d}\u{1}", &["\u{261d}",
+        "\u{1}"]), ("\u{261d}\u{308}\u{1}", &["\u{261d}\u{308}", "\u{1}"]), ("\u{261d}\u{300}",
+        &["\u{261d}\u{300}"]), ("\u{261d}\u{308}\u{300}", &["\u{261d}\u{308}\u{300}"]),
+        ("\u{261d}\u{600}", &["\u{261d}", "\u{600}"]), ("\u{261d}\u{308}\u{600}",
+        &["\u{261d}\u{308}", "\u{600}"]), ("\u{261d}\u{1100}", &["\u{261d}", "\u{1100}"]),
+        ("\u{261d}\u{308}\u{1100}", &["\u{261d}\u{308}", "\u{1100}"]), ("\u{261d}\u{1160}",
+        &["\u{261d}", "\u{1160}"]), ("\u{261d}\u{308}\u{1160}", &["\u{261d}\u{308}", "\u{1160}"]),
+        ("\u{261d}\u{11a8}", &["\u{261d}", "\u{11a8}"]), ("\u{261d}\u{308}\u{11a8}",
+        &["\u{261d}\u{308}", "\u{11a8}"]), ("\u{261d}\u{ac00}", &["\u{261d}", "\u{ac00}"]),
+        ("\u{261d}\u{308}\u{ac00}", &["\u{261d}\u{308}", "\u{ac00}"]), ("\u{261d}\u{ac01}",
+        &["\u{261d}", "\u{ac01}"]), ("\u{261d}\u{308}\u{ac01}", &["\u{261d}\u{308}", "\u{ac01}"]),
+        ("\u{261d}\u{1f1e6}", &["\u{261d}", "\u{1f1e6}"]), ("\u{261d}\u{308}\u{1f1e6}",
+        &["\u{261d}\u{308}", "\u{1f1e6}"]), ("\u{261d}\u{261d}", &["\u{261d}", "\u{261d}"]),
+        ("\u{261d}\u{308}\u{261d}", &["\u{261d}\u{308}", "\u{261d}"]), ("\u{261d}\u{1f3fb}",
+        &["\u{261d}\u{1f3fb}"]), ("\u{261d}\u{308}\u{1f3fb}", &["\u{261d}\u{308}\u{1f3fb}"]),
+        ("\u{261d}\u{200d}", &["\u{261d}\u{200d}"]), ("\u{261d}\u{308}\u{200d}",
+        &["\u{261d}\u{308}\u{200d}"]), ("\u{261d}\u{2764}", &["\u{261d}", "\u{2764}"]),
+        ("\u{261d}\u{308}\u{2764}", &["\u{261d}\u{308}", "\u{2764}"]), ("\u{261d}\u{1f466}",
+        &["\u{261d}", "\u{1f466}"]), ("\u{261d}\u{308}\u{1f466}", &["\u{261d}\u{308}",
+        "\u{1f466}"]), ("\u{261d}\u{378}", &["\u{261d}", "\u{378}"]), ("\u{261d}\u{308}\u{378}",
+        &["\u{261d}\u{308}", "\u{378}"]), ("\u{1f3fb}\u{20}", &["\u{1f3fb}", "\u{20}"]),
+        ("\u{1f3fb}\u{308}\u{20}", &["\u{1f3fb}\u{308}", "\u{20}"]), ("\u{1f3fb}\u{d}",
+        &["\u{1f3fb}", "\u{d}"]), ("\u{1f3fb}\u{308}\u{d}", &["\u{1f3fb}\u{308}", "\u{d}"]),
+        ("\u{1f3fb}\u{a}", &["\u{1f3fb}", "\u{a}"]), ("\u{1f3fb}\u{308}\u{a}", &["\u{1f3fb}\u{308}",
+        "\u{a}"]), ("\u{1f3fb}\u{1}", &["\u{1f3fb}", "\u{1}"]), ("\u{1f3fb}\u{308}\u{1}",
+        &["\u{1f3fb}\u{308}", "\u{1}"]), ("\u{1f3fb}\u{300}", &["\u{1f3fb}\u{300}"]),
+        ("\u{1f3fb}\u{308}\u{300}", &["\u{1f3fb}\u{308}\u{300}"]), ("\u{1f3fb}\u{600}",
+        &["\u{1f3fb}", "\u{600}"]), ("\u{1f3fb}\u{308}\u{600}", &["\u{1f3fb}\u{308}", "\u{600}"]),
+        ("\u{1f3fb}\u{1100}", &["\u{1f3fb}", "\u{1100}"]), ("\u{1f3fb}\u{308}\u{1100}",
+        &["\u{1f3fb}\u{308}", "\u{1100}"]), ("\u{1f3fb}\u{1160}", &["\u{1f3fb}", "\u{1160}"]),
+        ("\u{1f3fb}\u{308}\u{1160}", &["\u{1f3fb}\u{308}", "\u{1160}"]), ("\u{1f3fb}\u{11a8}",
+        &["\u{1f3fb}", "\u{11a8}"]), ("\u{1f3fb}\u{308}\u{11a8}", &["\u{1f3fb}\u{308}",
+        "\u{11a8}"]), ("\u{1f3fb}\u{ac00}", &["\u{1f3fb}", "\u{ac00}"]),
+        ("\u{1f3fb}\u{308}\u{ac00}", &["\u{1f3fb}\u{308}", "\u{ac00}"]), ("\u{1f3fb}\u{ac01}",
+        &["\u{1f3fb}", "\u{ac01}"]), ("\u{1f3fb}\u{308}\u{ac01}", &["\u{1f3fb}\u{308}",
+        "\u{ac01}"]), ("\u{1f3fb}\u{1f1e6}", &["\u{1f3fb}", "\u{1f1e6}"]),
+        ("\u{1f3fb}\u{308}\u{1f1e6}", &["\u{1f3fb}\u{308}", "\u{1f1e6}"]), ("\u{1f3fb}\u{261d}",
+        &["\u{1f3fb}", "\u{261d}"]), ("\u{1f3fb}\u{308}\u{261d}", &["\u{1f3fb}\u{308}",
+        "\u{261d}"]), ("\u{1f3fb}\u{1f3fb}", &["\u{1f3fb}", "\u{1f3fb}"]),
+        ("\u{1f3fb}\u{308}\u{1f3fb}", &["\u{1f3fb}\u{308}", "\u{1f3fb}"]), ("\u{1f3fb}\u{200d}",
+        &["\u{1f3fb}\u{200d}"]), ("\u{1f3fb}\u{308}\u{200d}", &["\u{1f3fb}\u{308}\u{200d}"]),
+        ("\u{1f3fb}\u{2764}", &["\u{1f3fb}", "\u{2764}"]), ("\u{1f3fb}\u{308}\u{2764}",
+        &["\u{1f3fb}\u{308}", "\u{2764}"]), ("\u{1f3fb}\u{1f466}", &["\u{1f3fb}", "\u{1f466}"]),
+        ("\u{1f3fb}\u{308}\u{1f466}", &["\u{1f3fb}\u{308}", "\u{1f466}"]), ("\u{1f3fb}\u{378}",
+        &["\u{1f3fb}", "\u{378}"]), ("\u{1f3fb}\u{308}\u{378}", &["\u{1f3fb}\u{308}", "\u{378}"]),
+        ("\u{200d}\u{20}", &["\u{200d}", "\u{20}"]), ("\u{200d}\u{308}\u{20}", &["\u{200d}\u{308}",
+        "\u{20}"]), ("\u{200d}\u{d}", &["\u{200d}", "\u{d}"]), ("\u{200d}\u{308}\u{d}",
+        &["\u{200d}\u{308}", "\u{d}"]), ("\u{200d}\u{a}", &["\u{200d}", "\u{a}"]),
+        ("\u{200d}\u{308}\u{a}", &["\u{200d}\u{308}", "\u{a}"]), ("\u{200d}\u{1}", &["\u{200d}",
+        "\u{1}"]), ("\u{200d}\u{308}\u{1}", &["\u{200d}\u{308}", "\u{1}"]), ("\u{200d}\u{300}",
+        &["\u{200d}\u{300}"]), ("\u{200d}\u{308}\u{300}", &["\u{200d}\u{308}\u{300}"]),
+        ("\u{200d}\u{600}", &["\u{200d}", "\u{600}"]), ("\u{200d}\u{308}\u{600}",
+        &["\u{200d}\u{308}", "\u{600}"]), ("\u{200d}\u{1100}", &["\u{200d}", "\u{1100}"]),
+        ("\u{200d}\u{308}\u{1100}", &["\u{200d}\u{308}", "\u{1100}"]), ("\u{200d}\u{1160}",
+        &["\u{200d}", "\u{1160}"]), ("\u{200d}\u{308}\u{1160}", &["\u{200d}\u{308}", "\u{1160}"]),
+        ("\u{200d}\u{11a8}", &["\u{200d}", "\u{11a8}"]), ("\u{200d}\u{308}\u{11a8}",
+        &["\u{200d}\u{308}", "\u{11a8}"]), ("\u{200d}\u{ac00}", &["\u{200d}", "\u{ac00}"]),
+        ("\u{200d}\u{308}\u{ac00}", &["\u{200d}\u{308}", "\u{ac00}"]), ("\u{200d}\u{ac01}",
+        &["\u{200d}", "\u{ac01}"]), ("\u{200d}\u{308}\u{ac01}", &["\u{200d}\u{308}", "\u{ac01}"]),
+        ("\u{200d}\u{1f1e6}", &["\u{200d}", "\u{1f1e6}"]), ("\u{200d}\u{308}\u{1f1e6}",
+        &["\u{200d}\u{308}", "\u{1f1e6}"]), ("\u{200d}\u{261d}", &["\u{200d}", "\u{261d}"]),
+        ("\u{200d}\u{308}\u{261d}", &["\u{200d}\u{308}", "\u{261d}"]), ("\u{200d}\u{1f3fb}",
+        &["\u{200d}", "\u{1f3fb}"]), ("\u{200d}\u{308}\u{1f3fb}", &["\u{200d}\u{308}",
+        "\u{1f3fb}"]), ("\u{200d}\u{200d}", &["\u{200d}\u{200d}"]), ("\u{200d}\u{308}\u{200d}",
+        &["\u{200d}\u{308}\u{200d}"]), ("\u{200d}\u{2764}", &["\u{200d}\u{2764}"]),
+        ("\u{200d}\u{308}\u{2764}", &["\u{200d}\u{308}", "\u{2764}"]), ("\u{200d}\u{1f466}",
+        &["\u{200d}\u{1f466}"]), ("\u{200d}\u{308}\u{1f466}", &["\u{200d}\u{308}", "\u{1f466}"]),
+        ("\u{200d}\u{378}", &["\u{200d}", "\u{378}"]), ("\u{200d}\u{308}\u{378}",
+        &["\u{200d}\u{308}", "\u{378}"]), ("\u{2764}\u{20}", &["\u{2764}", "\u{20}"]),
+        ("\u{2764}\u{308}\u{20}", &["\u{2764}\u{308}", "\u{20}"]), ("\u{2764}\u{d}", &["\u{2764}",
+        "\u{d}"]), ("\u{2764}\u{308}\u{d}", &["\u{2764}\u{308}", "\u{d}"]), ("\u{2764}\u{a}",
+        &["\u{2764}", "\u{a}"]), ("\u{2764}\u{308}\u{a}", &["\u{2764}\u{308}", "\u{a}"]),
+        ("\u{2764}\u{1}", &["\u{2764}", "\u{1}"]), ("\u{2764}\u{308}\u{1}", &["\u{2764}\u{308}",
+        "\u{1}"]), ("\u{2764}\u{300}", &["\u{2764}\u{300}"]), ("\u{2764}\u{308}\u{300}",
+        &["\u{2764}\u{308}\u{300}"]), ("\u{2764}\u{600}", &["\u{2764}", "\u{600}"]),
+        ("\u{2764}\u{308}\u{600}", &["\u{2764}\u{308}", "\u{600}"]), ("\u{2764}\u{1100}",
+        &["\u{2764}", "\u{1100}"]), ("\u{2764}\u{308}\u{1100}", &["\u{2764}\u{308}", "\u{1100}"]),
+        ("\u{2764}\u{1160}", &["\u{2764}", "\u{1160}"]), ("\u{2764}\u{308}\u{1160}",
+        &["\u{2764}\u{308}", "\u{1160}"]), ("\u{2764}\u{11a8}", &["\u{2764}", "\u{11a8}"]),
+        ("\u{2764}\u{308}\u{11a8}", &["\u{2764}\u{308}", "\u{11a8}"]), ("\u{2764}\u{ac00}",
+        &["\u{2764}", "\u{ac00}"]), ("\u{2764}\u{308}\u{ac00}", &["\u{2764}\u{308}", "\u{ac00}"]),
+        ("\u{2764}\u{ac01}", &["\u{2764}", "\u{ac01}"]), ("\u{2764}\u{308}\u{ac01}",
+        &["\u{2764}\u{308}", "\u{ac01}"]), ("\u{2764}\u{1f1e6}", &["\u{2764}", "\u{1f1e6}"]),
+        ("\u{2764}\u{308}\u{1f1e6}", &["\u{2764}\u{308}", "\u{1f1e6}"]), ("\u{2764}\u{261d}",
+        &["\u{2764}", "\u{261d}"]), ("\u{2764}\u{308}\u{261d}", &["\u{2764}\u{308}", "\u{261d}"]),
+        ("\u{2764}\u{1f3fb}", &["\u{2764}", "\u{1f3fb}"]), ("\u{2764}\u{308}\u{1f3fb}",
+        &["\u{2764}\u{308}", "\u{1f3fb}"]), ("\u{2764}\u{200d}", &["\u{2764}\u{200d}"]),
+        ("\u{2764}\u{308}\u{200d}", &["\u{2764}\u{308}\u{200d}"]), ("\u{2764}\u{2764}",
+        &["\u{2764}", "\u{2764}"]), ("\u{2764}\u{308}\u{2764}", &["\u{2764}\u{308}", "\u{2764}"]),
+        ("\u{2764}\u{1f466}", &["\u{2764}", "\u{1f466}"]), ("\u{2764}\u{308}\u{1f466}",
+        &["\u{2764}\u{308}", "\u{1f466}"]), ("\u{2764}\u{378}", &["\u{2764}", "\u{378}"]),
+        ("\u{2764}\u{308}\u{378}", &["\u{2764}\u{308}", "\u{378}"]), ("\u{1f466}\u{20}",
+        &["\u{1f466}", "\u{20}"]), ("\u{1f466}\u{308}\u{20}", &["\u{1f466}\u{308}", "\u{20}"]),
+        ("\u{1f466}\u{d}", &["\u{1f466}", "\u{d}"]), ("\u{1f466}\u{308}\u{d}", &["\u{1f466}\u{308}",
+        "\u{d}"]), ("\u{1f466}\u{a}", &["\u{1f466}", "\u{a}"]), ("\u{1f466}\u{308}\u{a}",
+        &["\u{1f466}\u{308}", "\u{a}"]), ("\u{1f466}\u{1}", &["\u{1f466}", "\u{1}"]),
+        ("\u{1f466}\u{308}\u{1}", &["\u{1f466}\u{308}", "\u{1}"]), ("\u{1f466}\u{300}",
+        &["\u{1f466}\u{300}"]), ("\u{1f466}\u{308}\u{300}", &["\u{1f466}\u{308}\u{300}"]),
+        ("\u{1f466}\u{600}", &["\u{1f466}", "\u{600}"]), ("\u{1f466}\u{308}\u{600}",
+        &["\u{1f466}\u{308}", "\u{600}"]), ("\u{1f466}\u{1100}", &["\u{1f466}", "\u{1100}"]),
+        ("\u{1f466}\u{308}\u{1100}", &["\u{1f466}\u{308}", "\u{1100}"]), ("\u{1f466}\u{1160}",
+        &["\u{1f466}", "\u{1160}"]), ("\u{1f466}\u{308}\u{1160}", &["\u{1f466}\u{308}",
+        "\u{1160}"]), ("\u{1f466}\u{11a8}", &["\u{1f466}", "\u{11a8}"]),
+        ("\u{1f466}\u{308}\u{11a8}", &["\u{1f466}\u{308}", "\u{11a8}"]), ("\u{1f466}\u{ac00}",
+        &["\u{1f466}", "\u{ac00}"]), ("\u{1f466}\u{308}\u{ac00}", &["\u{1f466}\u{308}",
+        "\u{ac00}"]), ("\u{1f466}\u{ac01}", &["\u{1f466}", "\u{ac01}"]),
+        ("\u{1f466}\u{308}\u{ac01}", &["\u{1f466}\u{308}", "\u{ac01}"]), ("\u{1f466}\u{1f1e6}",
+        &["\u{1f466}", "\u{1f1e6}"]), ("\u{1f466}\u{308}\u{1f1e6}", &["\u{1f466}\u{308}",
+        "\u{1f1e6}"]), ("\u{1f466}\u{261d}", &["\u{1f466}", "\u{261d}"]),
+        ("\u{1f466}\u{308}\u{261d}", &["\u{1f466}\u{308}", "\u{261d}"]), ("\u{1f466}\u{1f3fb}",
+        &["\u{1f466}\u{1f3fb}"]), ("\u{1f466}\u{308}\u{1f3fb}", &["\u{1f466}\u{308}\u{1f3fb}"]),
+        ("\u{1f466}\u{200d}", &["\u{1f466}\u{200d}"]), ("\u{1f466}\u{308}\u{200d}",
+        &["\u{1f466}\u{308}\u{200d}"]), ("\u{1f466}\u{2764}", &["\u{1f466}", "\u{2764}"]),
+        ("\u{1f466}\u{308}\u{2764}", &["\u{1f466}\u{308}", "\u{2764}"]), ("\u{1f466}\u{1f466}",
+        &["\u{1f466}", "\u{1f466}"]), ("\u{1f466}\u{308}\u{1f466}", &["\u{1f466}\u{308}",
+        "\u{1f466}"]), ("\u{1f466}\u{378}", &["\u{1f466}", "\u{378}"]), ("\u{1f466}\u{308}\u{378}",
+        &["\u{1f466}\u{308}", "\u{378}"]), ("\u{378}\u{20}", &["\u{378}", "\u{20}"]),
+        ("\u{378}\u{308}\u{20}", &["\u{378}\u{308}", "\u{20}"]), ("\u{378}\u{d}", &["\u{378}",
+        "\u{d}"]), ("\u{378}\u{308}\u{d}", &["\u{378}\u{308}", "\u{d}"]), ("\u{378}\u{a}",
+        &["\u{378}", "\u{a}"]), ("\u{378}\u{308}\u{a}", &["\u{378}\u{308}", "\u{a}"]),
+        ("\u{378}\u{1}", &["\u{378}", "\u{1}"]), ("\u{378}\u{308}\u{1}", &["\u{378}\u{308}",
+        "\u{1}"]), ("\u{378}\u{300}", &["\u{378}\u{300}"]), ("\u{378}\u{308}\u{300}",
+        &["\u{378}\u{308}\u{300}"]), ("\u{378}\u{600}", &["\u{378}", "\u{600}"]),
+        ("\u{378}\u{308}\u{600}", &["\u{378}\u{308}", "\u{600}"]), ("\u{378}\u{1100}", &["\u{378}",
+        "\u{1100}"]), ("\u{378}\u{308}\u{1100}", &["\u{378}\u{308}", "\u{1100}"]),
+        ("\u{378}\u{1160}", &["\u{378}", "\u{1160}"]), ("\u{378}\u{308}\u{1160}",
+        &["\u{378}\u{308}", "\u{1160}"]), ("\u{378}\u{11a8}", &["\u{378}", "\u{11a8}"]),
+        ("\u{378}\u{308}\u{11a8}", &["\u{378}\u{308}", "\u{11a8}"]), ("\u{378}\u{ac00}",
+        &["\u{378}", "\u{ac00}"]), ("\u{378}\u{308}\u{ac00}", &["\u{378}\u{308}", "\u{ac00}"]),
+        ("\u{378}\u{ac01}", &["\u{378}", "\u{ac01}"]), ("\u{378}\u{308}\u{ac01}",
+        &["\u{378}\u{308}", "\u{ac01}"]), ("\u{378}\u{1f1e6}", &["\u{378}", "\u{1f1e6}"]),
+        ("\u{378}\u{308}\u{1f1e6}", &["\u{378}\u{308}", "\u{1f1e6}"]), ("\u{378}\u{261d}",
+        &["\u{378}", "\u{261d}"]), ("\u{378}\u{308}\u{261d}", &["\u{378}\u{308}", "\u{261d}"]),
+        ("\u{378}\u{1f3fb}", &["\u{378}", "\u{1f3fb}"]), ("\u{378}\u{308}\u{1f3fb}",
+        &["\u{378}\u{308}", "\u{1f3fb}"]), ("\u{378}\u{200d}", &["\u{378}\u{200d}"]),
+        ("\u{378}\u{308}\u{200d}", &["\u{378}\u{308}\u{200d}"]), ("\u{378}\u{2764}", &["\u{378}",
+        "\u{2764}"]), ("\u{378}\u{308}\u{2764}", &["\u{378}\u{308}", "\u{2764}"]),
+        ("\u{378}\u{1f466}", &["\u{378}", "\u{1f466}"]), ("\u{378}\u{308}\u{1f466}",
+        &["\u{378}\u{308}", "\u{1f466}"]), ("\u{378}\u{378}", &["\u{378}", "\u{378}"]),
+        ("\u{378}\u{308}\u{378}", &["\u{378}\u{308}", "\u{378}"]), ("\u{d}\u{a}\u{61}\u{a}\u{308}",
+        &["\u{d}\u{a}", "\u{61}", "\u{a}", "\u{308}"]), ("\u{61}\u{308}", &["\u{61}\u{308}"]),
+        ("\u{20}\u{200d}\u{646}", &["\u{20}\u{200d}", "\u{646}"]), ("\u{646}\u{200d}\u{20}",
+        &["\u{646}\u{200d}", "\u{20}"]), ("\u{1100}\u{1100}", &["\u{1100}\u{1100}"]),
+        ("\u{ac00}\u{11a8}\u{1100}", &["\u{ac00}\u{11a8}", "\u{1100}"]),
+        ("\u{ac01}\u{11a8}\u{1100}", &["\u{ac01}\u{11a8}", "\u{1100}"]),
+        ("\u{1f1e6}\u{1f1e7}\u{1f1e8}\u{62}", &["\u{1f1e6}\u{1f1e7}", "\u{1f1e8}", "\u{62}"]),
+        ("\u{61}\u{1f1e6}\u{1f1e7}\u{1f1e8}\u{62}", &["\u{61}", "\u{1f1e6}\u{1f1e7}", "\u{1f1e8}",
+        "\u{62}"]), ("\u{61}\u{1f1e6}\u{1f1e7}\u{200d}\u{1f1e8}\u{62}", &["\u{61}",
+        "\u{1f1e6}\u{1f1e7}\u{200d}", "\u{1f1e8}", "\u{62}"]),
+        ("\u{61}\u{1f1e6}\u{200d}\u{1f1e7}\u{1f1e8}\u{62}", &["\u{61}", "\u{1f1e6}\u{200d}",
+        "\u{1f1e7}\u{1f1e8}", "\u{62}"]), ("\u{61}\u{1f1e6}\u{1f1e7}\u{1f1e8}\u{1f1e9}\u{62}",
+        &["\u{61}", "\u{1f1e6}\u{1f1e7}", "\u{1f1e8}\u{1f1e9}", "\u{62}"]), ("\u{61}\u{200d}",
+        &["\u{61}\u{200d}"]), ("\u{61}\u{308}\u{62}", &["\u{61}\u{308}", "\u{62}"]),
+        ("\u{261d}\u{1f3fb}\u{261d}", &["\u{261d}\u{1f3fb}", "\u{261d}"]), ("\u{1f466}\u{1f3fb}",
+        &["\u{1f466}\u{1f3fb}"]), ("\u{200d}\u{1f466}\u{1f3fb}", &["\u{200d}\u{1f466}\u{1f3fb}"]),
+        ("\u{200d}\u{2764}", &["\u{200d}\u{2764}"]), ("\u{200d}\u{1f466}", &["\u{200d}\u{1f466}"]),
+        ("\u{1f466}\u{1f466}", &["\u{1f466}", "\u{1f466}"])
+    ];
+
+    pub const TEST_DIFF: &'static [(&'static str, &'static [&'static str], &'static [&'static str])] = &[
+        ("\u{20}\u{903}", &["\u{20}\u{903}"], &["\u{20}", "\u{903}"]), ("\u{20}\u{308}\u{903}",
+        &["\u{20}\u{308}\u{903}"], &["\u{20}\u{308}", "\u{903}"]), ("\u{d}\u{308}\u{903}",
+        &["\u{d}", "\u{308}\u{903}"], &["\u{d}", "\u{308}", "\u{903}"]), ("\u{a}\u{308}\u{903}",
+        &["\u{a}", "\u{308}\u{903}"], &["\u{a}", "\u{308}", "\u{903}"]), ("\u{1}\u{308}\u{903}",
+        &["\u{1}", "\u{308}\u{903}"], &["\u{1}", "\u{308}", "\u{903}"]), ("\u{300}\u{903}",
+        &["\u{300}\u{903}"], &["\u{300}", "\u{903}"]), ("\u{300}\u{308}\u{903}",
+        &["\u{300}\u{308}\u{903}"], &["\u{300}\u{308}", "\u{903}"]), ("\u{600}\u{20}",
+        &["\u{600}\u{20}"], &["\u{600}", "\u{20}"]), ("\u{600}\u{600}", &["\u{600}\u{600}"],
+        &["\u{600}", "\u{600}"]), ("\u{600}\u{903}", &["\u{600}\u{903}"], &["\u{600}", "\u{903}"]),
+        ("\u{600}\u{308}\u{903}", &["\u{600}\u{308}\u{903}"], &["\u{600}\u{308}", "\u{903}"]),
+        ("\u{600}\u{1100}", &["\u{600}\u{1100}"], &["\u{600}", "\u{1100}"]), ("\u{600}\u{1160}",
+        &["\u{600}\u{1160}"], &["\u{600}", "\u{1160}"]), ("\u{600}\u{11a8}", &["\u{600}\u{11a8}"],
+        &["\u{600}", "\u{11a8}"]), ("\u{600}\u{ac00}", &["\u{600}\u{ac00}"], &["\u{600}",
+        "\u{ac00}"]), ("\u{600}\u{ac01}", &["\u{600}\u{ac01}"], &["\u{600}", "\u{ac01}"]),
+        ("\u{600}\u{1f1e6}", &["\u{600}\u{1f1e6}"], &["\u{600}", "\u{1f1e6}"]), ("\u{600}\u{261d}",
+        &["\u{600}\u{261d}"], &["\u{600}", "\u{261d}"]), ("\u{600}\u{1f3fb}", &["\u{600}\u{1f3fb}"],
+        &["\u{600}", "\u{1f3fb}"]), ("\u{600}\u{2764}", &["\u{600}\u{2764}"], &["\u{600}",
+        "\u{2764}"]), ("\u{600}\u{1f466}", &["\u{600}\u{1f466}"], &["\u{600}", "\u{1f466}"]),
+        ("\u{600}\u{378}", &["\u{600}\u{378}"], &["\u{600}", "\u{378}"]), ("\u{903}\u{903}",
+        &["\u{903}\u{903}"], &["\u{903}", "\u{903}"]), ("\u{903}\u{308}\u{903}",
+        &["\u{903}\u{308}\u{903}"], &["\u{903}\u{308}", "\u{903}"]), ("\u{1100}\u{903}",
+        &["\u{1100}\u{903}"], &["\u{1100}", "\u{903}"]), ("\u{1100}\u{308}\u{903}",
+        &["\u{1100}\u{308}\u{903}"], &["\u{1100}\u{308}", "\u{903}"]), ("\u{1160}\u{903}",
+        &["\u{1160}\u{903}"], &["\u{1160}", "\u{903}"]), ("\u{1160}\u{308}\u{903}",
+        &["\u{1160}\u{308}\u{903}"], &["\u{1160}\u{308}", "\u{903}"]), ("\u{11a8}\u{903}",
+        &["\u{11a8}\u{903}"], &["\u{11a8}", "\u{903}"]), ("\u{11a8}\u{308}\u{903}",
+        &["\u{11a8}\u{308}\u{903}"], &["\u{11a8}\u{308}", "\u{903}"]), ("\u{ac00}\u{903}",
+        &["\u{ac00}\u{903}"], &["\u{ac00}", "\u{903}"]), ("\u{ac00}\u{308}\u{903}",
+        &["\u{ac00}\u{308}\u{903}"], &["\u{ac00}\u{308}", "\u{903}"]), ("\u{ac01}\u{903}",
+        &["\u{ac01}\u{903}"], &["\u{ac01}", "\u{903}"]), ("\u{ac01}\u{308}\u{903}",
+        &["\u{ac01}\u{308}\u{903}"], &["\u{ac01}\u{308}", "\u{903}"]), ("\u{1f1e6}\u{903}",
+        &["\u{1f1e6}\u{903}"], &["\u{1f1e6}", "\u{903}"]), ("\u{1f1e6}\u{308}\u{903}",
+        &["\u{1f1e6}\u{308}\u{903}"], &["\u{1f1e6}\u{308}", "\u{903}"]), ("\u{261d}\u{903}",
+        &["\u{261d}\u{903}"], &["\u{261d}", "\u{903}"]), ("\u{261d}\u{308}\u{903}",
+        &["\u{261d}\u{308}\u{903}"], &["\u{261d}\u{308}", "\u{903}"]), ("\u{1f3fb}\u{903}",
+        &["\u{1f3fb}\u{903}"], &["\u{1f3fb}", "\u{903}"]), ("\u{1f3fb}\u{308}\u{903}",
+        &["\u{1f3fb}\u{308}\u{903}"], &["\u{1f3fb}\u{308}", "\u{903}"]), ("\u{200d}\u{903}",
+        &["\u{200d}\u{903}"], &["\u{200d}", "\u{903}"]), ("\u{200d}\u{308}\u{903}",
+        &["\u{200d}\u{308}\u{903}"], &["\u{200d}\u{308}", "\u{903}"]), ("\u{2764}\u{903}",
+        &["\u{2764}\u{903}"], &["\u{2764}", "\u{903}"]), ("\u{2764}\u{308}\u{903}",
+        &["\u{2764}\u{308}\u{903}"], &["\u{2764}\u{308}", "\u{903}"]), ("\u{1f466}\u{903}",
+        &["\u{1f466}\u{903}"], &["\u{1f466}", "\u{903}"]), ("\u{1f466}\u{308}\u{903}",
+        &["\u{1f466}\u{308}\u{903}"], &["\u{1f466}\u{308}", "\u{903}"]), ("\u{378}\u{903}",
+        &["\u{378}\u{903}"], &["\u{378}", "\u{903}"]), ("\u{378}\u{308}\u{903}",
+        &["\u{378}\u{308}\u{903}"], &["\u{378}\u{308}", "\u{903}"]), ("\u{61}\u{903}\u{62}",
+        &["\u{61}\u{903}", "\u{62}"], &["\u{61}", "\u{903}", "\u{62}"]), ("\u{61}\u{600}\u{62}",
+        &["\u{61}", "\u{600}\u{62}"], &["\u{61}", "\u{600}", "\u{62}"])
+    ];
+
+    // official Unicode test data
+    // http://www.unicode.org/Public/UNIDATA/auxiliary/WordBreakTest.txt
+    pub const TEST_WORD: &'static [(&'static str, &'static [&'static str])] = &[
+        ("\u{1}\u{1}", &["\u{1}", "\u{1}"]), ("\u{1}\u{308}\u{1}", &["\u{1}\u{308}", "\u{1}"]),
+        ("\u{1}\u{d}", &["\u{1}", "\u{d}"]), ("\u{1}\u{308}\u{d}", &["\u{1}\u{308}", "\u{d}"]),
+        ("\u{1}\u{a}", &["\u{1}", "\u{a}"]), ("\u{1}\u{308}\u{a}", &["\u{1}\u{308}", "\u{a}"]),
+        ("\u{1}\u{b}", &["\u{1}", "\u{b}"]), ("\u{1}\u{308}\u{b}", &["\u{1}\u{308}", "\u{b}"]),
+        ("\u{1}\u{3031}", &["\u{1}", "\u{3031}"]), ("\u{1}\u{308}\u{3031}", &["\u{1}\u{308}",
+        "\u{3031}"]), ("\u{1}\u{41}", &["\u{1}", "\u{41}"]), ("\u{1}\u{308}\u{41}",
+        &["\u{1}\u{308}", "\u{41}"]), ("\u{1}\u{3a}", &["\u{1}", "\u{3a}"]), ("\u{1}\u{308}\u{3a}",
+        &["\u{1}\u{308}", "\u{3a}"]), ("\u{1}\u{2c}", &["\u{1}", "\u{2c}"]), ("\u{1}\u{308}\u{2c}",
+        &["\u{1}\u{308}", "\u{2c}"]), ("\u{1}\u{2e}", &["\u{1}", "\u{2e}"]), ("\u{1}\u{308}\u{2e}",
+        &["\u{1}\u{308}", "\u{2e}"]), ("\u{1}\u{30}", &["\u{1}", "\u{30}"]), ("\u{1}\u{308}\u{30}",
+        &["\u{1}\u{308}", "\u{30}"]), ("\u{1}\u{5f}", &["\u{1}", "\u{5f}"]), ("\u{1}\u{308}\u{5f}",
+        &["\u{1}\u{308}", "\u{5f}"]), ("\u{1}\u{1f1e6}", &["\u{1}", "\u{1f1e6}"]),
+        ("\u{1}\u{308}\u{1f1e6}", &["\u{1}\u{308}", "\u{1f1e6}"]), ("\u{1}\u{5d0}", &["\u{1}",
+        "\u{5d0}"]), ("\u{1}\u{308}\u{5d0}", &["\u{1}\u{308}", "\u{5d0}"]), ("\u{1}\u{22}",
+        &["\u{1}", "\u{22}"]), ("\u{1}\u{308}\u{22}", &["\u{1}\u{308}", "\u{22}"]), ("\u{1}\u{27}",
+        &["\u{1}", "\u{27}"]), ("\u{1}\u{308}\u{27}", &["\u{1}\u{308}", "\u{27}"]),
+        ("\u{1}\u{261d}", &["\u{1}", "\u{261d}"]), ("\u{1}\u{308}\u{261d}", &["\u{1}\u{308}",
+        "\u{261d}"]), ("\u{1}\u{1f3fb}", &["\u{1}", "\u{1f3fb}"]), ("\u{1}\u{308}\u{1f3fb}",
+        &["\u{1}\u{308}", "\u{1f3fb}"]), ("\u{1}\u{2764}", &["\u{1}", "\u{2764}"]),
+        ("\u{1}\u{308}\u{2764}", &["\u{1}\u{308}", "\u{2764}"]), ("\u{1}\u{1f466}", &["\u{1}",
+        "\u{1f466}"]), ("\u{1}\u{308}\u{1f466}", &["\u{1}\u{308}", "\u{1f466}"]), ("\u{1}\u{ad}",
+        &["\u{1}\u{ad}"]), ("\u{1}\u{308}\u{ad}", &["\u{1}\u{308}\u{ad}"]), ("\u{1}\u{300}",
+        &["\u{1}\u{300}"]), ("\u{1}\u{308}\u{300}", &["\u{1}\u{308}\u{300}"]), ("\u{1}\u{200d}",
+        &["\u{1}\u{200d}"]), ("\u{1}\u{308}\u{200d}", &["\u{1}\u{308}\u{200d}"]),
+        ("\u{1}\u{61}\u{2060}", &["\u{1}", "\u{61}\u{2060}"]), ("\u{1}\u{308}\u{61}\u{2060}",
+        &["\u{1}\u{308}", "\u{61}\u{2060}"]), ("\u{1}\u{61}\u{3a}", &["\u{1}", "\u{61}", "\u{3a}"]),
+        ("\u{1}\u{308}\u{61}\u{3a}", &["\u{1}\u{308}", "\u{61}", "\u{3a}"]), ("\u{1}\u{61}\u{27}",
+        &["\u{1}", "\u{61}", "\u{27}"]), ("\u{1}\u{308}\u{61}\u{27}", &["\u{1}\u{308}", "\u{61}",
+        "\u{27}"]), ("\u{1}\u{61}\u{27}\u{2060}", &["\u{1}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1}\u{308}\u{61}\u{27}\u{2060}", &["\u{1}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1}\u{61}\u{2c}", &["\u{1}", "\u{61}", "\u{2c}"]), ("\u{1}\u{308}\u{61}\u{2c}",
+        &["\u{1}\u{308}", "\u{61}", "\u{2c}"]), ("\u{1}\u{31}\u{3a}", &["\u{1}", "\u{31}",
+        "\u{3a}"]), ("\u{1}\u{308}\u{31}\u{3a}", &["\u{1}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{1}\u{31}\u{27}", &["\u{1}", "\u{31}", "\u{27}"]), ("\u{1}\u{308}\u{31}\u{27}",
+        &["\u{1}\u{308}", "\u{31}", "\u{27}"]), ("\u{1}\u{31}\u{2c}", &["\u{1}", "\u{31}",
+        "\u{2c}"]), ("\u{1}\u{308}\u{31}\u{2c}", &["\u{1}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{1}\u{31}\u{2e}\u{2060}", &["\u{1}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1}\u{308}\u{31}\u{2e}\u{2060}", &["\u{1}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{d}\u{1}", &["\u{d}", "\u{1}"]), ("\u{d}\u{308}\u{1}", &["\u{d}", "\u{308}", "\u{1}"]),
+        ("\u{d}\u{d}", &["\u{d}", "\u{d}"]), ("\u{d}\u{308}\u{d}", &["\u{d}", "\u{308}", "\u{d}"]),
+        ("\u{d}\u{a}", &["\u{d}\u{a}"]), ("\u{d}\u{308}\u{a}", &["\u{d}", "\u{308}", "\u{a}"]),
+        ("\u{d}\u{b}", &["\u{d}", "\u{b}"]), ("\u{d}\u{308}\u{b}", &["\u{d}", "\u{308}", "\u{b}"]),
+        ("\u{d}\u{3031}", &["\u{d}", "\u{3031}"]), ("\u{d}\u{308}\u{3031}", &["\u{d}", "\u{308}",
+        "\u{3031}"]), ("\u{d}\u{41}", &["\u{d}", "\u{41}"]), ("\u{d}\u{308}\u{41}", &["\u{d}",
+        "\u{308}", "\u{41}"]), ("\u{d}\u{3a}", &["\u{d}", "\u{3a}"]), ("\u{d}\u{308}\u{3a}",
+        &["\u{d}", "\u{308}", "\u{3a}"]), ("\u{d}\u{2c}", &["\u{d}", "\u{2c}"]),
+        ("\u{d}\u{308}\u{2c}", &["\u{d}", "\u{308}", "\u{2c}"]), ("\u{d}\u{2e}", &["\u{d}",
+        "\u{2e}"]), ("\u{d}\u{308}\u{2e}", &["\u{d}", "\u{308}", "\u{2e}"]), ("\u{d}\u{30}",
+        &["\u{d}", "\u{30}"]), ("\u{d}\u{308}\u{30}", &["\u{d}", "\u{308}", "\u{30}"]),
+        ("\u{d}\u{5f}", &["\u{d}", "\u{5f}"]), ("\u{d}\u{308}\u{5f}", &["\u{d}", "\u{308}",
+        "\u{5f}"]), ("\u{d}\u{1f1e6}", &["\u{d}", "\u{1f1e6}"]), ("\u{d}\u{308}\u{1f1e6}",
+        &["\u{d}", "\u{308}", "\u{1f1e6}"]), ("\u{d}\u{5d0}", &["\u{d}", "\u{5d0}"]),
+        ("\u{d}\u{308}\u{5d0}", &["\u{d}", "\u{308}", "\u{5d0}"]), ("\u{d}\u{22}", &["\u{d}",
+        "\u{22}"]), ("\u{d}\u{308}\u{22}", &["\u{d}", "\u{308}", "\u{22}"]), ("\u{d}\u{27}",
+        &["\u{d}", "\u{27}"]), ("\u{d}\u{308}\u{27}", &["\u{d}", "\u{308}", "\u{27}"]),
+        ("\u{d}\u{261d}", &["\u{d}", "\u{261d}"]), ("\u{d}\u{308}\u{261d}", &["\u{d}", "\u{308}",
+        "\u{261d}"]), ("\u{d}\u{1f3fb}", &["\u{d}", "\u{1f3fb}"]), ("\u{d}\u{308}\u{1f3fb}",
+        &["\u{d}", "\u{308}", "\u{1f3fb}"]), ("\u{d}\u{2764}", &["\u{d}", "\u{2764}"]),
+        ("\u{d}\u{308}\u{2764}", &["\u{d}", "\u{308}", "\u{2764}"]), ("\u{d}\u{1f466}", &["\u{d}",
+        "\u{1f466}"]), ("\u{d}\u{308}\u{1f466}", &["\u{d}", "\u{308}", "\u{1f466}"]),
+        ("\u{d}\u{ad}", &["\u{d}", "\u{ad}"]), ("\u{d}\u{308}\u{ad}", &["\u{d}", "\u{308}\u{ad}"]),
+        ("\u{d}\u{300}", &["\u{d}", "\u{300}"]), ("\u{d}\u{308}\u{300}", &["\u{d}",
+        "\u{308}\u{300}"]), ("\u{d}\u{200d}", &["\u{d}", "\u{200d}"]), ("\u{d}\u{308}\u{200d}",
+        &["\u{d}", "\u{308}\u{200d}"]), ("\u{d}\u{61}\u{2060}", &["\u{d}", "\u{61}\u{2060}"]),
+        ("\u{d}\u{308}\u{61}\u{2060}", &["\u{d}", "\u{308}", "\u{61}\u{2060}"]),
+        ("\u{d}\u{61}\u{3a}", &["\u{d}", "\u{61}", "\u{3a}"]), ("\u{d}\u{308}\u{61}\u{3a}",
+        &["\u{d}", "\u{308}", "\u{61}", "\u{3a}"]), ("\u{d}\u{61}\u{27}", &["\u{d}", "\u{61}",
+        "\u{27}"]), ("\u{d}\u{308}\u{61}\u{27}", &["\u{d}", "\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{d}\u{61}\u{27}\u{2060}", &["\u{d}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{d}\u{308}\u{61}\u{27}\u{2060}", &["\u{d}", "\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{d}\u{61}\u{2c}", &["\u{d}", "\u{61}", "\u{2c}"]), ("\u{d}\u{308}\u{61}\u{2c}",
+        &["\u{d}", "\u{308}", "\u{61}", "\u{2c}"]), ("\u{d}\u{31}\u{3a}", &["\u{d}", "\u{31}",
+        "\u{3a}"]), ("\u{d}\u{308}\u{31}\u{3a}", &["\u{d}", "\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{d}\u{31}\u{27}", &["\u{d}", "\u{31}", "\u{27}"]), ("\u{d}\u{308}\u{31}\u{27}",
+        &["\u{d}", "\u{308}", "\u{31}", "\u{27}"]), ("\u{d}\u{31}\u{2c}", &["\u{d}", "\u{31}",
+        "\u{2c}"]), ("\u{d}\u{308}\u{31}\u{2c}", &["\u{d}", "\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{d}\u{31}\u{2e}\u{2060}", &["\u{d}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{d}\u{308}\u{31}\u{2e}\u{2060}", &["\u{d}", "\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{a}\u{1}", &["\u{a}", "\u{1}"]), ("\u{a}\u{308}\u{1}", &["\u{a}", "\u{308}", "\u{1}"]),
+        ("\u{a}\u{d}", &["\u{a}", "\u{d}"]), ("\u{a}\u{308}\u{d}", &["\u{a}", "\u{308}", "\u{d}"]),
+        ("\u{a}\u{a}", &["\u{a}", "\u{a}"]), ("\u{a}\u{308}\u{a}", &["\u{a}", "\u{308}", "\u{a}"]),
+        ("\u{a}\u{b}", &["\u{a}", "\u{b}"]), ("\u{a}\u{308}\u{b}", &["\u{a}", "\u{308}", "\u{b}"]),
+        ("\u{a}\u{3031}", &["\u{a}", "\u{3031}"]), ("\u{a}\u{308}\u{3031}", &["\u{a}", "\u{308}",
+        "\u{3031}"]), ("\u{a}\u{41}", &["\u{a}", "\u{41}"]), ("\u{a}\u{308}\u{41}", &["\u{a}",
+        "\u{308}", "\u{41}"]), ("\u{a}\u{3a}", &["\u{a}", "\u{3a}"]), ("\u{a}\u{308}\u{3a}",
+        &["\u{a}", "\u{308}", "\u{3a}"]), ("\u{a}\u{2c}", &["\u{a}", "\u{2c}"]),
+        ("\u{a}\u{308}\u{2c}", &["\u{a}", "\u{308}", "\u{2c}"]), ("\u{a}\u{2e}", &["\u{a}",
+        "\u{2e}"]), ("\u{a}\u{308}\u{2e}", &["\u{a}", "\u{308}", "\u{2e}"]), ("\u{a}\u{30}",
+        &["\u{a}", "\u{30}"]), ("\u{a}\u{308}\u{30}", &["\u{a}", "\u{308}", "\u{30}"]),
+        ("\u{a}\u{5f}", &["\u{a}", "\u{5f}"]), ("\u{a}\u{308}\u{5f}", &["\u{a}", "\u{308}",
+        "\u{5f}"]), ("\u{a}\u{1f1e6}", &["\u{a}", "\u{1f1e6}"]), ("\u{a}\u{308}\u{1f1e6}",
+        &["\u{a}", "\u{308}", "\u{1f1e6}"]), ("\u{a}\u{5d0}", &["\u{a}", "\u{5d0}"]),
+        ("\u{a}\u{308}\u{5d0}", &["\u{a}", "\u{308}", "\u{5d0}"]), ("\u{a}\u{22}", &["\u{a}",
+        "\u{22}"]), ("\u{a}\u{308}\u{22}", &["\u{a}", "\u{308}", "\u{22}"]), ("\u{a}\u{27}",
+        &["\u{a}", "\u{27}"]), ("\u{a}\u{308}\u{27}", &["\u{a}", "\u{308}", "\u{27}"]),
+        ("\u{a}\u{261d}", &["\u{a}", "\u{261d}"]), ("\u{a}\u{308}\u{261d}", &["\u{a}", "\u{308}",
+        "\u{261d}"]), ("\u{a}\u{1f3fb}", &["\u{a}", "\u{1f3fb}"]), ("\u{a}\u{308}\u{1f3fb}",
+        &["\u{a}", "\u{308}", "\u{1f3fb}"]), ("\u{a}\u{2764}", &["\u{a}", "\u{2764}"]),
+        ("\u{a}\u{308}\u{2764}", &["\u{a}", "\u{308}", "\u{2764}"]), ("\u{a}\u{1f466}", &["\u{a}",
+        "\u{1f466}"]), ("\u{a}\u{308}\u{1f466}", &["\u{a}", "\u{308}", "\u{1f466}"]),
+        ("\u{a}\u{ad}", &["\u{a}", "\u{ad}"]), ("\u{a}\u{308}\u{ad}", &["\u{a}", "\u{308}\u{ad}"]),
+        ("\u{a}\u{300}", &["\u{a}", "\u{300}"]), ("\u{a}\u{308}\u{300}", &["\u{a}",
+        "\u{308}\u{300}"]), ("\u{a}\u{200d}", &["\u{a}", "\u{200d}"]), ("\u{a}\u{308}\u{200d}",
+        &["\u{a}", "\u{308}\u{200d}"]), ("\u{a}\u{61}\u{2060}", &["\u{a}", "\u{61}\u{2060}"]),
+        ("\u{a}\u{308}\u{61}\u{2060}", &["\u{a}", "\u{308}", "\u{61}\u{2060}"]),
+        ("\u{a}\u{61}\u{3a}", &["\u{a}", "\u{61}", "\u{3a}"]), ("\u{a}\u{308}\u{61}\u{3a}",
+        &["\u{a}", "\u{308}", "\u{61}", "\u{3a}"]), ("\u{a}\u{61}\u{27}", &["\u{a}", "\u{61}",
+        "\u{27}"]), ("\u{a}\u{308}\u{61}\u{27}", &["\u{a}", "\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{a}\u{61}\u{27}\u{2060}", &["\u{a}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{a}\u{308}\u{61}\u{27}\u{2060}", &["\u{a}", "\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{a}\u{61}\u{2c}", &["\u{a}", "\u{61}", "\u{2c}"]), ("\u{a}\u{308}\u{61}\u{2c}",
+        &["\u{a}", "\u{308}", "\u{61}", "\u{2c}"]), ("\u{a}\u{31}\u{3a}", &["\u{a}", "\u{31}",
+        "\u{3a}"]), ("\u{a}\u{308}\u{31}\u{3a}", &["\u{a}", "\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{a}\u{31}\u{27}", &["\u{a}", "\u{31}", "\u{27}"]), ("\u{a}\u{308}\u{31}\u{27}",
+        &["\u{a}", "\u{308}", "\u{31}", "\u{27}"]), ("\u{a}\u{31}\u{2c}", &["\u{a}", "\u{31}",
+        "\u{2c}"]), ("\u{a}\u{308}\u{31}\u{2c}", &["\u{a}", "\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{a}\u{31}\u{2e}\u{2060}", &["\u{a}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{a}\u{308}\u{31}\u{2e}\u{2060}", &["\u{a}", "\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{b}\u{1}", &["\u{b}", "\u{1}"]), ("\u{b}\u{308}\u{1}", &["\u{b}", "\u{308}", "\u{1}"]),
+        ("\u{b}\u{d}", &["\u{b}", "\u{d}"]), ("\u{b}\u{308}\u{d}", &["\u{b}", "\u{308}", "\u{d}"]),
+        ("\u{b}\u{a}", &["\u{b}", "\u{a}"]), ("\u{b}\u{308}\u{a}", &["\u{b}", "\u{308}", "\u{a}"]),
+        ("\u{b}\u{b}", &["\u{b}", "\u{b}"]), ("\u{b}\u{308}\u{b}", &["\u{b}", "\u{308}", "\u{b}"]),
+        ("\u{b}\u{3031}", &["\u{b}", "\u{3031}"]), ("\u{b}\u{308}\u{3031}", &["\u{b}", "\u{308}",
+        "\u{3031}"]), ("\u{b}\u{41}", &["\u{b}", "\u{41}"]), ("\u{b}\u{308}\u{41}", &["\u{b}",
+        "\u{308}", "\u{41}"]), ("\u{b}\u{3a}", &["\u{b}", "\u{3a}"]), ("\u{b}\u{308}\u{3a}",
+        &["\u{b}", "\u{308}", "\u{3a}"]), ("\u{b}\u{2c}", &["\u{b}", "\u{2c}"]),
+        ("\u{b}\u{308}\u{2c}", &["\u{b}", "\u{308}", "\u{2c}"]), ("\u{b}\u{2e}", &["\u{b}",
+        "\u{2e}"]), ("\u{b}\u{308}\u{2e}", &["\u{b}", "\u{308}", "\u{2e}"]), ("\u{b}\u{30}",
+        &["\u{b}", "\u{30}"]), ("\u{b}\u{308}\u{30}", &["\u{b}", "\u{308}", "\u{30}"]),
+        ("\u{b}\u{5f}", &["\u{b}", "\u{5f}"]), ("\u{b}\u{308}\u{5f}", &["\u{b}", "\u{308}",
+        "\u{5f}"]), ("\u{b}\u{1f1e6}", &["\u{b}", "\u{1f1e6}"]), ("\u{b}\u{308}\u{1f1e6}",
+        &["\u{b}", "\u{308}", "\u{1f1e6}"]), ("\u{b}\u{5d0}", &["\u{b}", "\u{5d0}"]),
+        ("\u{b}\u{308}\u{5d0}", &["\u{b}", "\u{308}", "\u{5d0}"]), ("\u{b}\u{22}", &["\u{b}",
+        "\u{22}"]), ("\u{b}\u{308}\u{22}", &["\u{b}", "\u{308}", "\u{22}"]), ("\u{b}\u{27}",
+        &["\u{b}", "\u{27}"]), ("\u{b}\u{308}\u{27}", &["\u{b}", "\u{308}", "\u{27}"]),
+        ("\u{b}\u{261d}", &["\u{b}", "\u{261d}"]), ("\u{b}\u{308}\u{261d}", &["\u{b}", "\u{308}",
+        "\u{261d}"]), ("\u{b}\u{1f3fb}", &["\u{b}", "\u{1f3fb}"]), ("\u{b}\u{308}\u{1f3fb}",
+        &["\u{b}", "\u{308}", "\u{1f3fb}"]), ("\u{b}\u{2764}", &["\u{b}", "\u{2764}"]),
+        ("\u{b}\u{308}\u{2764}", &["\u{b}", "\u{308}", "\u{2764}"]), ("\u{b}\u{1f466}", &["\u{b}",
+        "\u{1f466}"]), ("\u{b}\u{308}\u{1f466}", &["\u{b}", "\u{308}", "\u{1f466}"]),
+        ("\u{b}\u{ad}", &["\u{b}", "\u{ad}"]), ("\u{b}\u{308}\u{ad}", &["\u{b}", "\u{308}\u{ad}"]),
+        ("\u{b}\u{300}", &["\u{b}", "\u{300}"]), ("\u{b}\u{308}\u{300}", &["\u{b}",
+        "\u{308}\u{300}"]), ("\u{b}\u{200d}", &["\u{b}", "\u{200d}"]), ("\u{b}\u{308}\u{200d}",
+        &["\u{b}", "\u{308}\u{200d}"]), ("\u{b}\u{61}\u{2060}", &["\u{b}", "\u{61}\u{2060}"]),
+        ("\u{b}\u{308}\u{61}\u{2060}", &["\u{b}", "\u{308}", "\u{61}\u{2060}"]),
+        ("\u{b}\u{61}\u{3a}", &["\u{b}", "\u{61}", "\u{3a}"]), ("\u{b}\u{308}\u{61}\u{3a}",
+        &["\u{b}", "\u{308}", "\u{61}", "\u{3a}"]), ("\u{b}\u{61}\u{27}", &["\u{b}", "\u{61}",
+        "\u{27}"]), ("\u{b}\u{308}\u{61}\u{27}", &["\u{b}", "\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{b}\u{61}\u{27}\u{2060}", &["\u{b}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{b}\u{308}\u{61}\u{27}\u{2060}", &["\u{b}", "\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{b}\u{61}\u{2c}", &["\u{b}", "\u{61}", "\u{2c}"]), ("\u{b}\u{308}\u{61}\u{2c}",
+        &["\u{b}", "\u{308}", "\u{61}", "\u{2c}"]), ("\u{b}\u{31}\u{3a}", &["\u{b}", "\u{31}",
+        "\u{3a}"]), ("\u{b}\u{308}\u{31}\u{3a}", &["\u{b}", "\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{b}\u{31}\u{27}", &["\u{b}", "\u{31}", "\u{27}"]), ("\u{b}\u{308}\u{31}\u{27}",
+        &["\u{b}", "\u{308}", "\u{31}", "\u{27}"]), ("\u{b}\u{31}\u{2c}", &["\u{b}", "\u{31}",
+        "\u{2c}"]), ("\u{b}\u{308}\u{31}\u{2c}", &["\u{b}", "\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{b}\u{31}\u{2e}\u{2060}", &["\u{b}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{b}\u{308}\u{31}\u{2e}\u{2060}", &["\u{b}", "\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{3031}\u{1}", &["\u{3031}", "\u{1}"]), ("\u{3031}\u{308}\u{1}", &["\u{3031}\u{308}",
+        "\u{1}"]), ("\u{3031}\u{d}", &["\u{3031}", "\u{d}"]), ("\u{3031}\u{308}\u{d}",
+        &["\u{3031}\u{308}", "\u{d}"]), ("\u{3031}\u{a}", &["\u{3031}", "\u{a}"]),
+        ("\u{3031}\u{308}\u{a}", &["\u{3031}\u{308}", "\u{a}"]), ("\u{3031}\u{b}", &["\u{3031}",
+        "\u{b}"]), ("\u{3031}\u{308}\u{b}", &["\u{3031}\u{308}", "\u{b}"]), ("\u{3031}\u{3031}",
+        &["\u{3031}\u{3031}"]), ("\u{3031}\u{308}\u{3031}", &["\u{3031}\u{308}\u{3031}"]),
+        ("\u{3031}\u{41}", &["\u{3031}", "\u{41}"]), ("\u{3031}\u{308}\u{41}", &["\u{3031}\u{308}",
+        "\u{41}"]), ("\u{3031}\u{3a}", &["\u{3031}", "\u{3a}"]), ("\u{3031}\u{308}\u{3a}",
+        &["\u{3031}\u{308}", "\u{3a}"]), ("\u{3031}\u{2c}", &["\u{3031}", "\u{2c}"]),
+        ("\u{3031}\u{308}\u{2c}", &["\u{3031}\u{308}", "\u{2c}"]), ("\u{3031}\u{2e}", &["\u{3031}",
+        "\u{2e}"]), ("\u{3031}\u{308}\u{2e}", &["\u{3031}\u{308}", "\u{2e}"]), ("\u{3031}\u{30}",
+        &["\u{3031}", "\u{30}"]), ("\u{3031}\u{308}\u{30}", &["\u{3031}\u{308}", "\u{30}"]),
+        ("\u{3031}\u{5f}", &["\u{3031}\u{5f}"]), ("\u{3031}\u{308}\u{5f}",
+        &["\u{3031}\u{308}\u{5f}"]), ("\u{3031}\u{1f1e6}", &["\u{3031}", "\u{1f1e6}"]),
+        ("\u{3031}\u{308}\u{1f1e6}", &["\u{3031}\u{308}", "\u{1f1e6}"]), ("\u{3031}\u{5d0}",
+        &["\u{3031}", "\u{5d0}"]), ("\u{3031}\u{308}\u{5d0}", &["\u{3031}\u{308}", "\u{5d0}"]),
+        ("\u{3031}\u{22}", &["\u{3031}", "\u{22}"]), ("\u{3031}\u{308}\u{22}", &["\u{3031}\u{308}",
+        "\u{22}"]), ("\u{3031}\u{27}", &["\u{3031}", "\u{27}"]), ("\u{3031}\u{308}\u{27}",
+        &["\u{3031}\u{308}", "\u{27}"]), ("\u{3031}\u{261d}", &["\u{3031}", "\u{261d}"]),
+        ("\u{3031}\u{308}\u{261d}", &["\u{3031}\u{308}", "\u{261d}"]), ("\u{3031}\u{1f3fb}",
+        &["\u{3031}", "\u{1f3fb}"]), ("\u{3031}\u{308}\u{1f3fb}", &["\u{3031}\u{308}",
+        "\u{1f3fb}"]), ("\u{3031}\u{2764}", &["\u{3031}", "\u{2764}"]), ("\u{3031}\u{308}\u{2764}",
+        &["\u{3031}\u{308}", "\u{2764}"]), ("\u{3031}\u{1f466}", &["\u{3031}", "\u{1f466}"]),
+        ("\u{3031}\u{308}\u{1f466}", &["\u{3031}\u{308}", "\u{1f466}"]), ("\u{3031}\u{ad}",
+        &["\u{3031}\u{ad}"]), ("\u{3031}\u{308}\u{ad}", &["\u{3031}\u{308}\u{ad}"]),
+        ("\u{3031}\u{300}", &["\u{3031}\u{300}"]), ("\u{3031}\u{308}\u{300}",
+        &["\u{3031}\u{308}\u{300}"]), ("\u{3031}\u{200d}", &["\u{3031}\u{200d}"]),
+        ("\u{3031}\u{308}\u{200d}", &["\u{3031}\u{308}\u{200d}"]), ("\u{3031}\u{61}\u{2060}",
+        &["\u{3031}", "\u{61}\u{2060}"]), ("\u{3031}\u{308}\u{61}\u{2060}", &["\u{3031}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{3031}\u{61}\u{3a}", &["\u{3031}", "\u{61}", "\u{3a}"]),
+        ("\u{3031}\u{308}\u{61}\u{3a}", &["\u{3031}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{3031}\u{61}\u{27}", &["\u{3031}", "\u{61}", "\u{27}"]), ("\u{3031}\u{308}\u{61}\u{27}",
+        &["\u{3031}\u{308}", "\u{61}", "\u{27}"]), ("\u{3031}\u{61}\u{27}\u{2060}", &["\u{3031}",
+        "\u{61}", "\u{27}\u{2060}"]), ("\u{3031}\u{308}\u{61}\u{27}\u{2060}", &["\u{3031}\u{308}",
+        "\u{61}", "\u{27}\u{2060}"]), ("\u{3031}\u{61}\u{2c}", &["\u{3031}", "\u{61}", "\u{2c}"]),
+        ("\u{3031}\u{308}\u{61}\u{2c}", &["\u{3031}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{3031}\u{31}\u{3a}", &["\u{3031}", "\u{31}", "\u{3a}"]), ("\u{3031}\u{308}\u{31}\u{3a}",
+        &["\u{3031}\u{308}", "\u{31}", "\u{3a}"]), ("\u{3031}\u{31}\u{27}", &["\u{3031}", "\u{31}",
+        "\u{27}"]), ("\u{3031}\u{308}\u{31}\u{27}", &["\u{3031}\u{308}", "\u{31}", "\u{27}"]),
+        ("\u{3031}\u{31}\u{2c}", &["\u{3031}", "\u{31}", "\u{2c}"]), ("\u{3031}\u{308}\u{31}\u{2c}",
+        &["\u{3031}\u{308}", "\u{31}", "\u{2c}"]), ("\u{3031}\u{31}\u{2e}\u{2060}", &["\u{3031}",
+        "\u{31}", "\u{2e}\u{2060}"]), ("\u{3031}\u{308}\u{31}\u{2e}\u{2060}", &["\u{3031}\u{308}",
+        "\u{31}", "\u{2e}\u{2060}"]), ("\u{41}\u{1}", &["\u{41}", "\u{1}"]), ("\u{41}\u{308}\u{1}",
+        &["\u{41}\u{308}", "\u{1}"]), ("\u{41}\u{d}", &["\u{41}", "\u{d}"]), ("\u{41}\u{308}\u{d}",
+        &["\u{41}\u{308}", "\u{d}"]), ("\u{41}\u{a}", &["\u{41}", "\u{a}"]), ("\u{41}\u{308}\u{a}",
+        &["\u{41}\u{308}", "\u{a}"]), ("\u{41}\u{b}", &["\u{41}", "\u{b}"]), ("\u{41}\u{308}\u{b}",
+        &["\u{41}\u{308}", "\u{b}"]), ("\u{41}\u{3031}", &["\u{41}", "\u{3031}"]),
+        ("\u{41}\u{308}\u{3031}", &["\u{41}\u{308}", "\u{3031}"]), ("\u{41}\u{41}",
+        &["\u{41}\u{41}"]), ("\u{41}\u{308}\u{41}", &["\u{41}\u{308}\u{41}"]), ("\u{41}\u{3a}",
+        &["\u{41}", "\u{3a}"]), ("\u{41}\u{308}\u{3a}", &["\u{41}\u{308}", "\u{3a}"]),
+        ("\u{41}\u{2c}", &["\u{41}", "\u{2c}"]), ("\u{41}\u{308}\u{2c}", &["\u{41}\u{308}",
+        "\u{2c}"]), ("\u{41}\u{2e}", &["\u{41}", "\u{2e}"]), ("\u{41}\u{308}\u{2e}",
+        &["\u{41}\u{308}", "\u{2e}"]), ("\u{41}\u{30}", &["\u{41}\u{30}"]), ("\u{41}\u{308}\u{30}",
+        &["\u{41}\u{308}\u{30}"]), ("\u{41}\u{5f}", &["\u{41}\u{5f}"]), ("\u{41}\u{308}\u{5f}",
+        &["\u{41}\u{308}\u{5f}"]), ("\u{41}\u{1f1e6}", &["\u{41}", "\u{1f1e6}"]),
+        ("\u{41}\u{308}\u{1f1e6}", &["\u{41}\u{308}", "\u{1f1e6}"]), ("\u{41}\u{5d0}",
+        &["\u{41}\u{5d0}"]), ("\u{41}\u{308}\u{5d0}", &["\u{41}\u{308}\u{5d0}"]), ("\u{41}\u{22}",
+        &["\u{41}", "\u{22}"]), ("\u{41}\u{308}\u{22}", &["\u{41}\u{308}", "\u{22}"]),
+        ("\u{41}\u{27}", &["\u{41}", "\u{27}"]), ("\u{41}\u{308}\u{27}", &["\u{41}\u{308}",
+        "\u{27}"]), ("\u{41}\u{261d}", &["\u{41}", "\u{261d}"]), ("\u{41}\u{308}\u{261d}",
+        &["\u{41}\u{308}", "\u{261d}"]), ("\u{41}\u{1f3fb}", &["\u{41}", "\u{1f3fb}"]),
+        ("\u{41}\u{308}\u{1f3fb}", &["\u{41}\u{308}", "\u{1f3fb}"]), ("\u{41}\u{2764}", &["\u{41}",
+        "\u{2764}"]), ("\u{41}\u{308}\u{2764}", &["\u{41}\u{308}", "\u{2764}"]), ("\u{41}\u{1f466}",
+        &["\u{41}", "\u{1f466}"]), ("\u{41}\u{308}\u{1f466}", &["\u{41}\u{308}", "\u{1f466}"]),
+        ("\u{41}\u{ad}", &["\u{41}\u{ad}"]), ("\u{41}\u{308}\u{ad}", &["\u{41}\u{308}\u{ad}"]),
+        ("\u{41}\u{300}", &["\u{41}\u{300}"]), ("\u{41}\u{308}\u{300}", &["\u{41}\u{308}\u{300}"]),
+        ("\u{41}\u{200d}", &["\u{41}\u{200d}"]), ("\u{41}\u{308}\u{200d}",
+        &["\u{41}\u{308}\u{200d}"]), ("\u{41}\u{61}\u{2060}", &["\u{41}\u{61}\u{2060}"]),
+        ("\u{41}\u{308}\u{61}\u{2060}", &["\u{41}\u{308}\u{61}\u{2060}"]), ("\u{41}\u{61}\u{3a}",
+        &["\u{41}\u{61}", "\u{3a}"]), ("\u{41}\u{308}\u{61}\u{3a}", &["\u{41}\u{308}\u{61}",
+        "\u{3a}"]), ("\u{41}\u{61}\u{27}", &["\u{41}\u{61}", "\u{27}"]),
+        ("\u{41}\u{308}\u{61}\u{27}", &["\u{41}\u{308}\u{61}", "\u{27}"]),
+        ("\u{41}\u{61}\u{27}\u{2060}", &["\u{41}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{41}\u{308}\u{61}\u{27}\u{2060}", &["\u{41}\u{308}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{41}\u{61}\u{2c}", &["\u{41}\u{61}", "\u{2c}"]), ("\u{41}\u{308}\u{61}\u{2c}",
+        &["\u{41}\u{308}\u{61}", "\u{2c}"]), ("\u{41}\u{31}\u{3a}", &["\u{41}\u{31}", "\u{3a}"]),
+        ("\u{41}\u{308}\u{31}\u{3a}", &["\u{41}\u{308}\u{31}", "\u{3a}"]), ("\u{41}\u{31}\u{27}",
+        &["\u{41}\u{31}", "\u{27}"]), ("\u{41}\u{308}\u{31}\u{27}", &["\u{41}\u{308}\u{31}",
+        "\u{27}"]), ("\u{41}\u{31}\u{2c}", &["\u{41}\u{31}", "\u{2c}"]),
+        ("\u{41}\u{308}\u{31}\u{2c}", &["\u{41}\u{308}\u{31}", "\u{2c}"]),
+        ("\u{41}\u{31}\u{2e}\u{2060}", &["\u{41}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{41}\u{308}\u{31}\u{2e}\u{2060}", &["\u{41}\u{308}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{3a}\u{1}", &["\u{3a}", "\u{1}"]), ("\u{3a}\u{308}\u{1}", &["\u{3a}\u{308}", "\u{1}"]),
+        ("\u{3a}\u{d}", &["\u{3a}", "\u{d}"]), ("\u{3a}\u{308}\u{d}", &["\u{3a}\u{308}", "\u{d}"]),
+        ("\u{3a}\u{a}", &["\u{3a}", "\u{a}"]), ("\u{3a}\u{308}\u{a}", &["\u{3a}\u{308}", "\u{a}"]),
+        ("\u{3a}\u{b}", &["\u{3a}", "\u{b}"]), ("\u{3a}\u{308}\u{b}", &["\u{3a}\u{308}", "\u{b}"]),
+        ("\u{3a}\u{3031}", &["\u{3a}", "\u{3031}"]), ("\u{3a}\u{308}\u{3031}", &["\u{3a}\u{308}",
+        "\u{3031}"]), ("\u{3a}\u{41}", &["\u{3a}", "\u{41}"]), ("\u{3a}\u{308}\u{41}",
+        &["\u{3a}\u{308}", "\u{41}"]), ("\u{3a}\u{3a}", &["\u{3a}", "\u{3a}"]),
+        ("\u{3a}\u{308}\u{3a}", &["\u{3a}\u{308}", "\u{3a}"]), ("\u{3a}\u{2c}", &["\u{3a}",
+        "\u{2c}"]), ("\u{3a}\u{308}\u{2c}", &["\u{3a}\u{308}", "\u{2c}"]), ("\u{3a}\u{2e}",
+        &["\u{3a}", "\u{2e}"]), ("\u{3a}\u{308}\u{2e}", &["\u{3a}\u{308}", "\u{2e}"]),
+        ("\u{3a}\u{30}", &["\u{3a}", "\u{30}"]), ("\u{3a}\u{308}\u{30}", &["\u{3a}\u{308}",
+        "\u{30}"]), ("\u{3a}\u{5f}", &["\u{3a}", "\u{5f}"]), ("\u{3a}\u{308}\u{5f}",
+        &["\u{3a}\u{308}", "\u{5f}"]), ("\u{3a}\u{1f1e6}", &["\u{3a}", "\u{1f1e6}"]),
+        ("\u{3a}\u{308}\u{1f1e6}", &["\u{3a}\u{308}", "\u{1f1e6}"]), ("\u{3a}\u{5d0}", &["\u{3a}",
+        "\u{5d0}"]), ("\u{3a}\u{308}\u{5d0}", &["\u{3a}\u{308}", "\u{5d0}"]), ("\u{3a}\u{22}",
+        &["\u{3a}", "\u{22}"]), ("\u{3a}\u{308}\u{22}", &["\u{3a}\u{308}", "\u{22}"]),
+        ("\u{3a}\u{27}", &["\u{3a}", "\u{27}"]), ("\u{3a}\u{308}\u{27}", &["\u{3a}\u{308}",
+        "\u{27}"]), ("\u{3a}\u{261d}", &["\u{3a}", "\u{261d}"]), ("\u{3a}\u{308}\u{261d}",
+        &["\u{3a}\u{308}", "\u{261d}"]), ("\u{3a}\u{1f3fb}", &["\u{3a}", "\u{1f3fb}"]),
+        ("\u{3a}\u{308}\u{1f3fb}", &["\u{3a}\u{308}", "\u{1f3fb}"]), ("\u{3a}\u{2764}", &["\u{3a}",
+        "\u{2764}"]), ("\u{3a}\u{308}\u{2764}", &["\u{3a}\u{308}", "\u{2764}"]), ("\u{3a}\u{1f466}",
+        &["\u{3a}", "\u{1f466}"]), ("\u{3a}\u{308}\u{1f466}", &["\u{3a}\u{308}", "\u{1f466}"]),
+        ("\u{3a}\u{ad}", &["\u{3a}\u{ad}"]), ("\u{3a}\u{308}\u{ad}", &["\u{3a}\u{308}\u{ad}"]),
+        ("\u{3a}\u{300}", &["\u{3a}\u{300}"]), ("\u{3a}\u{308}\u{300}", &["\u{3a}\u{308}\u{300}"]),
+        ("\u{3a}\u{200d}", &["\u{3a}\u{200d}"]), ("\u{3a}\u{308}\u{200d}",
+        &["\u{3a}\u{308}\u{200d}"]), ("\u{3a}\u{61}\u{2060}", &["\u{3a}", "\u{61}\u{2060}"]),
+        ("\u{3a}\u{308}\u{61}\u{2060}", &["\u{3a}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{3a}\u{61}\u{3a}", &["\u{3a}", "\u{61}", "\u{3a}"]), ("\u{3a}\u{308}\u{61}\u{3a}",
+        &["\u{3a}\u{308}", "\u{61}", "\u{3a}"]), ("\u{3a}\u{61}\u{27}", &["\u{3a}", "\u{61}",
+        "\u{27}"]), ("\u{3a}\u{308}\u{61}\u{27}", &["\u{3a}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{3a}\u{61}\u{27}\u{2060}", &["\u{3a}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{3a}\u{308}\u{61}\u{27}\u{2060}", &["\u{3a}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{3a}\u{61}\u{2c}", &["\u{3a}", "\u{61}", "\u{2c}"]), ("\u{3a}\u{308}\u{61}\u{2c}",
+        &["\u{3a}\u{308}", "\u{61}", "\u{2c}"]), ("\u{3a}\u{31}\u{3a}", &["\u{3a}", "\u{31}",
+        "\u{3a}"]), ("\u{3a}\u{308}\u{31}\u{3a}", &["\u{3a}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{3a}\u{31}\u{27}", &["\u{3a}", "\u{31}", "\u{27}"]), ("\u{3a}\u{308}\u{31}\u{27}",
+        &["\u{3a}\u{308}", "\u{31}", "\u{27}"]), ("\u{3a}\u{31}\u{2c}", &["\u{3a}", "\u{31}",
+        "\u{2c}"]), ("\u{3a}\u{308}\u{31}\u{2c}", &["\u{3a}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{3a}\u{31}\u{2e}\u{2060}", &["\u{3a}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{3a}\u{308}\u{31}\u{2e}\u{2060}", &["\u{3a}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{2c}\u{1}", &["\u{2c}", "\u{1}"]), ("\u{2c}\u{308}\u{1}", &["\u{2c}\u{308}", "\u{1}"]),
+        ("\u{2c}\u{d}", &["\u{2c}", "\u{d}"]), ("\u{2c}\u{308}\u{d}", &["\u{2c}\u{308}", "\u{d}"]),
+        ("\u{2c}\u{a}", &["\u{2c}", "\u{a}"]), ("\u{2c}\u{308}\u{a}", &["\u{2c}\u{308}", "\u{a}"]),
+        ("\u{2c}\u{b}", &["\u{2c}", "\u{b}"]), ("\u{2c}\u{308}\u{b}", &["\u{2c}\u{308}", "\u{b}"]),
+        ("\u{2c}\u{3031}", &["\u{2c}", "\u{3031}"]), ("\u{2c}\u{308}\u{3031}", &["\u{2c}\u{308}",
+        "\u{3031}"]), ("\u{2c}\u{41}", &["\u{2c}", "\u{41}"]), ("\u{2c}\u{308}\u{41}",
+        &["\u{2c}\u{308}", "\u{41}"]), ("\u{2c}\u{3a}", &["\u{2c}", "\u{3a}"]),
+        ("\u{2c}\u{308}\u{3a}", &["\u{2c}\u{308}", "\u{3a}"]), ("\u{2c}\u{2c}", &["\u{2c}",
+        "\u{2c}"]), ("\u{2c}\u{308}\u{2c}", &["\u{2c}\u{308}", "\u{2c}"]), ("\u{2c}\u{2e}",
+        &["\u{2c}", "\u{2e}"]), ("\u{2c}\u{308}\u{2e}", &["\u{2c}\u{308}", "\u{2e}"]),
+        ("\u{2c}\u{30}", &["\u{2c}", "\u{30}"]), ("\u{2c}\u{308}\u{30}", &["\u{2c}\u{308}",
+        "\u{30}"]), ("\u{2c}\u{5f}", &["\u{2c}", "\u{5f}"]), ("\u{2c}\u{308}\u{5f}",
+        &["\u{2c}\u{308}", "\u{5f}"]), ("\u{2c}\u{1f1e6}", &["\u{2c}", "\u{1f1e6}"]),
+        ("\u{2c}\u{308}\u{1f1e6}", &["\u{2c}\u{308}", "\u{1f1e6}"]), ("\u{2c}\u{5d0}", &["\u{2c}",
+        "\u{5d0}"]), ("\u{2c}\u{308}\u{5d0}", &["\u{2c}\u{308}", "\u{5d0}"]), ("\u{2c}\u{22}",
+        &["\u{2c}", "\u{22}"]), ("\u{2c}\u{308}\u{22}", &["\u{2c}\u{308}", "\u{22}"]),
+        ("\u{2c}\u{27}", &["\u{2c}", "\u{27}"]), ("\u{2c}\u{308}\u{27}", &["\u{2c}\u{308}",
+        "\u{27}"]), ("\u{2c}\u{261d}", &["\u{2c}", "\u{261d}"]), ("\u{2c}\u{308}\u{261d}",
+        &["\u{2c}\u{308}", "\u{261d}"]), ("\u{2c}\u{1f3fb}", &["\u{2c}", "\u{1f3fb}"]),
+        ("\u{2c}\u{308}\u{1f3fb}", &["\u{2c}\u{308}", "\u{1f3fb}"]), ("\u{2c}\u{2764}", &["\u{2c}",
+        "\u{2764}"]), ("\u{2c}\u{308}\u{2764}", &["\u{2c}\u{308}", "\u{2764}"]), ("\u{2c}\u{1f466}",
+        &["\u{2c}", "\u{1f466}"]), ("\u{2c}\u{308}\u{1f466}", &["\u{2c}\u{308}", "\u{1f466}"]),
+        ("\u{2c}\u{ad}", &["\u{2c}\u{ad}"]), ("\u{2c}\u{308}\u{ad}", &["\u{2c}\u{308}\u{ad}"]),
+        ("\u{2c}\u{300}", &["\u{2c}\u{300}"]), ("\u{2c}\u{308}\u{300}", &["\u{2c}\u{308}\u{300}"]),
+        ("\u{2c}\u{200d}", &["\u{2c}\u{200d}"]), ("\u{2c}\u{308}\u{200d}",
+        &["\u{2c}\u{308}\u{200d}"]), ("\u{2c}\u{61}\u{2060}", &["\u{2c}", "\u{61}\u{2060}"]),
+        ("\u{2c}\u{308}\u{61}\u{2060}", &["\u{2c}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{2c}\u{61}\u{3a}", &["\u{2c}", "\u{61}", "\u{3a}"]), ("\u{2c}\u{308}\u{61}\u{3a}",
+        &["\u{2c}\u{308}", "\u{61}", "\u{3a}"]), ("\u{2c}\u{61}\u{27}", &["\u{2c}", "\u{61}",
+        "\u{27}"]), ("\u{2c}\u{308}\u{61}\u{27}", &["\u{2c}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{2c}\u{61}\u{27}\u{2060}", &["\u{2c}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{2c}\u{308}\u{61}\u{27}\u{2060}", &["\u{2c}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{2c}\u{61}\u{2c}", &["\u{2c}", "\u{61}", "\u{2c}"]), ("\u{2c}\u{308}\u{61}\u{2c}",
+        &["\u{2c}\u{308}", "\u{61}", "\u{2c}"]), ("\u{2c}\u{31}\u{3a}", &["\u{2c}", "\u{31}",
+        "\u{3a}"]), ("\u{2c}\u{308}\u{31}\u{3a}", &["\u{2c}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{2c}\u{31}\u{27}", &["\u{2c}", "\u{31}", "\u{27}"]), ("\u{2c}\u{308}\u{31}\u{27}",
+        &["\u{2c}\u{308}", "\u{31}", "\u{27}"]), ("\u{2c}\u{31}\u{2c}", &["\u{2c}", "\u{31}",
+        "\u{2c}"]), ("\u{2c}\u{308}\u{31}\u{2c}", &["\u{2c}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{2c}\u{31}\u{2e}\u{2060}", &["\u{2c}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{2c}\u{308}\u{31}\u{2e}\u{2060}", &["\u{2c}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{2e}\u{1}", &["\u{2e}", "\u{1}"]), ("\u{2e}\u{308}\u{1}", &["\u{2e}\u{308}", "\u{1}"]),
+        ("\u{2e}\u{d}", &["\u{2e}", "\u{d}"]), ("\u{2e}\u{308}\u{d}", &["\u{2e}\u{308}", "\u{d}"]),
+        ("\u{2e}\u{a}", &["\u{2e}", "\u{a}"]), ("\u{2e}\u{308}\u{a}", &["\u{2e}\u{308}", "\u{a}"]),
+        ("\u{2e}\u{b}", &["\u{2e}", "\u{b}"]), ("\u{2e}\u{308}\u{b}", &["\u{2e}\u{308}", "\u{b}"]),
+        ("\u{2e}\u{3031}", &["\u{2e}", "\u{3031}"]), ("\u{2e}\u{308}\u{3031}", &["\u{2e}\u{308}",
+        "\u{3031}"]), ("\u{2e}\u{41}", &["\u{2e}", "\u{41}"]), ("\u{2e}\u{308}\u{41}",
+        &["\u{2e}\u{308}", "\u{41}"]), ("\u{2e}\u{3a}", &["\u{2e}", "\u{3a}"]),
+        ("\u{2e}\u{308}\u{3a}", &["\u{2e}\u{308}", "\u{3a}"]), ("\u{2e}\u{2c}", &["\u{2e}",
+        "\u{2c}"]), ("\u{2e}\u{308}\u{2c}", &["\u{2e}\u{308}", "\u{2c}"]), ("\u{2e}\u{2e}",
+        &["\u{2e}", "\u{2e}"]), ("\u{2e}\u{308}\u{2e}", &["\u{2e}\u{308}", "\u{2e}"]),
+        ("\u{2e}\u{30}", &["\u{2e}", "\u{30}"]), ("\u{2e}\u{308}\u{30}", &["\u{2e}\u{308}",
+        "\u{30}"]), ("\u{2e}\u{5f}", &["\u{2e}", "\u{5f}"]), ("\u{2e}\u{308}\u{5f}",
+        &["\u{2e}\u{308}", "\u{5f}"]), ("\u{2e}\u{1f1e6}", &["\u{2e}", "\u{1f1e6}"]),
+        ("\u{2e}\u{308}\u{1f1e6}", &["\u{2e}\u{308}", "\u{1f1e6}"]), ("\u{2e}\u{5d0}", &["\u{2e}",
+        "\u{5d0}"]), ("\u{2e}\u{308}\u{5d0}", &["\u{2e}\u{308}", "\u{5d0}"]), ("\u{2e}\u{22}",
+        &["\u{2e}", "\u{22}"]), ("\u{2e}\u{308}\u{22}", &["\u{2e}\u{308}", "\u{22}"]),
+        ("\u{2e}\u{27}", &["\u{2e}", "\u{27}"]), ("\u{2e}\u{308}\u{27}", &["\u{2e}\u{308}",
+        "\u{27}"]), ("\u{2e}\u{261d}", &["\u{2e}", "\u{261d}"]), ("\u{2e}\u{308}\u{261d}",
+        &["\u{2e}\u{308}", "\u{261d}"]), ("\u{2e}\u{1f3fb}", &["\u{2e}", "\u{1f3fb}"]),
+        ("\u{2e}\u{308}\u{1f3fb}", &["\u{2e}\u{308}", "\u{1f3fb}"]), ("\u{2e}\u{2764}", &["\u{2e}",
+        "\u{2764}"]), ("\u{2e}\u{308}\u{2764}", &["\u{2e}\u{308}", "\u{2764}"]), ("\u{2e}\u{1f466}",
+        &["\u{2e}", "\u{1f466}"]), ("\u{2e}\u{308}\u{1f466}", &["\u{2e}\u{308}", "\u{1f466}"]),
+        ("\u{2e}\u{ad}", &["\u{2e}\u{ad}"]), ("\u{2e}\u{308}\u{ad}", &["\u{2e}\u{308}\u{ad}"]),
+        ("\u{2e}\u{300}", &["\u{2e}\u{300}"]), ("\u{2e}\u{308}\u{300}", &["\u{2e}\u{308}\u{300}"]),
+        ("\u{2e}\u{200d}", &["\u{2e}\u{200d}"]), ("\u{2e}\u{308}\u{200d}",
+        &["\u{2e}\u{308}\u{200d}"]), ("\u{2e}\u{61}\u{2060}", &["\u{2e}", "\u{61}\u{2060}"]),
+        ("\u{2e}\u{308}\u{61}\u{2060}", &["\u{2e}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{2e}\u{61}\u{3a}", &["\u{2e}", "\u{61}", "\u{3a}"]), ("\u{2e}\u{308}\u{61}\u{3a}",
+        &["\u{2e}\u{308}", "\u{61}", "\u{3a}"]), ("\u{2e}\u{61}\u{27}", &["\u{2e}", "\u{61}",
+        "\u{27}"]), ("\u{2e}\u{308}\u{61}\u{27}", &["\u{2e}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{2e}\u{61}\u{27}\u{2060}", &["\u{2e}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{2e}\u{308}\u{61}\u{27}\u{2060}", &["\u{2e}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{2e}\u{61}\u{2c}", &["\u{2e}", "\u{61}", "\u{2c}"]), ("\u{2e}\u{308}\u{61}\u{2c}",
+        &["\u{2e}\u{308}", "\u{61}", "\u{2c}"]), ("\u{2e}\u{31}\u{3a}", &["\u{2e}", "\u{31}",
+        "\u{3a}"]), ("\u{2e}\u{308}\u{31}\u{3a}", &["\u{2e}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{2e}\u{31}\u{27}", &["\u{2e}", "\u{31}", "\u{27}"]), ("\u{2e}\u{308}\u{31}\u{27}",
+        &["\u{2e}\u{308}", "\u{31}", "\u{27}"]), ("\u{2e}\u{31}\u{2c}", &["\u{2e}", "\u{31}",
+        "\u{2c}"]), ("\u{2e}\u{308}\u{31}\u{2c}", &["\u{2e}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{2e}\u{31}\u{2e}\u{2060}", &["\u{2e}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{2e}\u{308}\u{31}\u{2e}\u{2060}", &["\u{2e}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{30}\u{1}", &["\u{30}", "\u{1}"]), ("\u{30}\u{308}\u{1}", &["\u{30}\u{308}", "\u{1}"]),
+        ("\u{30}\u{d}", &["\u{30}", "\u{d}"]), ("\u{30}\u{308}\u{d}", &["\u{30}\u{308}", "\u{d}"]),
+        ("\u{30}\u{a}", &["\u{30}", "\u{a}"]), ("\u{30}\u{308}\u{a}", &["\u{30}\u{308}", "\u{a}"]),
+        ("\u{30}\u{b}", &["\u{30}", "\u{b}"]), ("\u{30}\u{308}\u{b}", &["\u{30}\u{308}", "\u{b}"]),
+        ("\u{30}\u{3031}", &["\u{30}", "\u{3031}"]), ("\u{30}\u{308}\u{3031}", &["\u{30}\u{308}",
+        "\u{3031}"]), ("\u{30}\u{41}", &["\u{30}\u{41}"]), ("\u{30}\u{308}\u{41}",
+        &["\u{30}\u{308}\u{41}"]), ("\u{30}\u{3a}", &["\u{30}", "\u{3a}"]), ("\u{30}\u{308}\u{3a}",
+        &["\u{30}\u{308}", "\u{3a}"]), ("\u{30}\u{2c}", &["\u{30}", "\u{2c}"]),
+        ("\u{30}\u{308}\u{2c}", &["\u{30}\u{308}", "\u{2c}"]), ("\u{30}\u{2e}", &["\u{30}",
+        "\u{2e}"]), ("\u{30}\u{308}\u{2e}", &["\u{30}\u{308}", "\u{2e}"]), ("\u{30}\u{30}",
+        &["\u{30}\u{30}"]), ("\u{30}\u{308}\u{30}", &["\u{30}\u{308}\u{30}"]), ("\u{30}\u{5f}",
+        &["\u{30}\u{5f}"]), ("\u{30}\u{308}\u{5f}", &["\u{30}\u{308}\u{5f}"]), ("\u{30}\u{1f1e6}",
+        &["\u{30}", "\u{1f1e6}"]), ("\u{30}\u{308}\u{1f1e6}", &["\u{30}\u{308}", "\u{1f1e6}"]),
+        ("\u{30}\u{5d0}", &["\u{30}\u{5d0}"]), ("\u{30}\u{308}\u{5d0}", &["\u{30}\u{308}\u{5d0}"]),
+        ("\u{30}\u{22}", &["\u{30}", "\u{22}"]), ("\u{30}\u{308}\u{22}", &["\u{30}\u{308}",
+        "\u{22}"]), ("\u{30}\u{27}", &["\u{30}", "\u{27}"]), ("\u{30}\u{308}\u{27}",
+        &["\u{30}\u{308}", "\u{27}"]), ("\u{30}\u{261d}", &["\u{30}", "\u{261d}"]),
+        ("\u{30}\u{308}\u{261d}", &["\u{30}\u{308}", "\u{261d}"]), ("\u{30}\u{1f3fb}", &["\u{30}",
+        "\u{1f3fb}"]), ("\u{30}\u{308}\u{1f3fb}", &["\u{30}\u{308}", "\u{1f3fb}"]),
+        ("\u{30}\u{2764}", &["\u{30}", "\u{2764}"]), ("\u{30}\u{308}\u{2764}", &["\u{30}\u{308}",
+        "\u{2764}"]), ("\u{30}\u{1f466}", &["\u{30}", "\u{1f466}"]), ("\u{30}\u{308}\u{1f466}",
+        &["\u{30}\u{308}", "\u{1f466}"]), ("\u{30}\u{ad}", &["\u{30}\u{ad}"]),
+        ("\u{30}\u{308}\u{ad}", &["\u{30}\u{308}\u{ad}"]), ("\u{30}\u{300}", &["\u{30}\u{300}"]),
+        ("\u{30}\u{308}\u{300}", &["\u{30}\u{308}\u{300}"]), ("\u{30}\u{200d}",
+        &["\u{30}\u{200d}"]), ("\u{30}\u{308}\u{200d}", &["\u{30}\u{308}\u{200d}"]),
+        ("\u{30}\u{61}\u{2060}", &["\u{30}\u{61}\u{2060}"]), ("\u{30}\u{308}\u{61}\u{2060}",
+        &["\u{30}\u{308}\u{61}\u{2060}"]), ("\u{30}\u{61}\u{3a}", &["\u{30}\u{61}", "\u{3a}"]),
+        ("\u{30}\u{308}\u{61}\u{3a}", &["\u{30}\u{308}\u{61}", "\u{3a}"]), ("\u{30}\u{61}\u{27}",
+        &["\u{30}\u{61}", "\u{27}"]), ("\u{30}\u{308}\u{61}\u{27}", &["\u{30}\u{308}\u{61}",
+        "\u{27}"]), ("\u{30}\u{61}\u{27}\u{2060}", &["\u{30}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{30}\u{308}\u{61}\u{27}\u{2060}", &["\u{30}\u{308}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{30}\u{61}\u{2c}", &["\u{30}\u{61}", "\u{2c}"]), ("\u{30}\u{308}\u{61}\u{2c}",
+        &["\u{30}\u{308}\u{61}", "\u{2c}"]), ("\u{30}\u{31}\u{3a}", &["\u{30}\u{31}", "\u{3a}"]),
+        ("\u{30}\u{308}\u{31}\u{3a}", &["\u{30}\u{308}\u{31}", "\u{3a}"]), ("\u{30}\u{31}\u{27}",
+        &["\u{30}\u{31}", "\u{27}"]), ("\u{30}\u{308}\u{31}\u{27}", &["\u{30}\u{308}\u{31}",
+        "\u{27}"]), ("\u{30}\u{31}\u{2c}", &["\u{30}\u{31}", "\u{2c}"]),
+        ("\u{30}\u{308}\u{31}\u{2c}", &["\u{30}\u{308}\u{31}", "\u{2c}"]),
+        ("\u{30}\u{31}\u{2e}\u{2060}", &["\u{30}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{30}\u{308}\u{31}\u{2e}\u{2060}", &["\u{30}\u{308}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{5f}\u{1}", &["\u{5f}", "\u{1}"]), ("\u{5f}\u{308}\u{1}", &["\u{5f}\u{308}", "\u{1}"]),
+        ("\u{5f}\u{d}", &["\u{5f}", "\u{d}"]), ("\u{5f}\u{308}\u{d}", &["\u{5f}\u{308}", "\u{d}"]),
+        ("\u{5f}\u{a}", &["\u{5f}", "\u{a}"]), ("\u{5f}\u{308}\u{a}", &["\u{5f}\u{308}", "\u{a}"]),
+        ("\u{5f}\u{b}", &["\u{5f}", "\u{b}"]), ("\u{5f}\u{308}\u{b}", &["\u{5f}\u{308}", "\u{b}"]),
+        ("\u{5f}\u{3031}", &["\u{5f}\u{3031}"]), ("\u{5f}\u{308}\u{3031}",
+        &["\u{5f}\u{308}\u{3031}"]), ("\u{5f}\u{41}", &["\u{5f}\u{41}"]), ("\u{5f}\u{308}\u{41}",
+        &["\u{5f}\u{308}\u{41}"]), ("\u{5f}\u{3a}", &["\u{5f}", "\u{3a}"]), ("\u{5f}\u{308}\u{3a}",
+        &["\u{5f}\u{308}", "\u{3a}"]), ("\u{5f}\u{2c}", &["\u{5f}", "\u{2c}"]),
+        ("\u{5f}\u{308}\u{2c}", &["\u{5f}\u{308}", "\u{2c}"]), ("\u{5f}\u{2e}", &["\u{5f}",
+        "\u{2e}"]), ("\u{5f}\u{308}\u{2e}", &["\u{5f}\u{308}", "\u{2e}"]), ("\u{5f}\u{30}",
+        &["\u{5f}\u{30}"]), ("\u{5f}\u{308}\u{30}", &["\u{5f}\u{308}\u{30}"]), ("\u{5f}\u{5f}",
+        &["\u{5f}\u{5f}"]), ("\u{5f}\u{308}\u{5f}", &["\u{5f}\u{308}\u{5f}"]), ("\u{5f}\u{1f1e6}",
+        &["\u{5f}", "\u{1f1e6}"]), ("\u{5f}\u{308}\u{1f1e6}", &["\u{5f}\u{308}", "\u{1f1e6}"]),
+        ("\u{5f}\u{5d0}", &["\u{5f}\u{5d0}"]), ("\u{5f}\u{308}\u{5d0}", &["\u{5f}\u{308}\u{5d0}"]),
+        ("\u{5f}\u{22}", &["\u{5f}", "\u{22}"]), ("\u{5f}\u{308}\u{22}", &["\u{5f}\u{308}",
+        "\u{22}"]), ("\u{5f}\u{27}", &["\u{5f}", "\u{27}"]), ("\u{5f}\u{308}\u{27}",
+        &["\u{5f}\u{308}", "\u{27}"]), ("\u{5f}\u{261d}", &["\u{5f}", "\u{261d}"]),
+        ("\u{5f}\u{308}\u{261d}", &["\u{5f}\u{308}", "\u{261d}"]), ("\u{5f}\u{1f3fb}", &["\u{5f}",
+        "\u{1f3fb}"]), ("\u{5f}\u{308}\u{1f3fb}", &["\u{5f}\u{308}", "\u{1f3fb}"]),
+        ("\u{5f}\u{2764}", &["\u{5f}", "\u{2764}"]), ("\u{5f}\u{308}\u{2764}", &["\u{5f}\u{308}",
+        "\u{2764}"]), ("\u{5f}\u{1f466}", &["\u{5f}", "\u{1f466}"]), ("\u{5f}\u{308}\u{1f466}",
+        &["\u{5f}\u{308}", "\u{1f466}"]), ("\u{5f}\u{ad}", &["\u{5f}\u{ad}"]),
+        ("\u{5f}\u{308}\u{ad}", &["\u{5f}\u{308}\u{ad}"]), ("\u{5f}\u{300}", &["\u{5f}\u{300}"]),
+        ("\u{5f}\u{308}\u{300}", &["\u{5f}\u{308}\u{300}"]), ("\u{5f}\u{200d}",
+        &["\u{5f}\u{200d}"]), ("\u{5f}\u{308}\u{200d}", &["\u{5f}\u{308}\u{200d}"]),
+        ("\u{5f}\u{61}\u{2060}", &["\u{5f}\u{61}\u{2060}"]), ("\u{5f}\u{308}\u{61}\u{2060}",
+        &["\u{5f}\u{308}\u{61}\u{2060}"]), ("\u{5f}\u{61}\u{3a}", &["\u{5f}\u{61}", "\u{3a}"]),
+        ("\u{5f}\u{308}\u{61}\u{3a}", &["\u{5f}\u{308}\u{61}", "\u{3a}"]), ("\u{5f}\u{61}\u{27}",
+        &["\u{5f}\u{61}", "\u{27}"]), ("\u{5f}\u{308}\u{61}\u{27}", &["\u{5f}\u{308}\u{61}",
+        "\u{27}"]), ("\u{5f}\u{61}\u{27}\u{2060}", &["\u{5f}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{5f}\u{308}\u{61}\u{27}\u{2060}", &["\u{5f}\u{308}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{5f}\u{61}\u{2c}", &["\u{5f}\u{61}", "\u{2c}"]), ("\u{5f}\u{308}\u{61}\u{2c}",
+        &["\u{5f}\u{308}\u{61}", "\u{2c}"]), ("\u{5f}\u{31}\u{3a}", &["\u{5f}\u{31}", "\u{3a}"]),
+        ("\u{5f}\u{308}\u{31}\u{3a}", &["\u{5f}\u{308}\u{31}", "\u{3a}"]), ("\u{5f}\u{31}\u{27}",
+        &["\u{5f}\u{31}", "\u{27}"]), ("\u{5f}\u{308}\u{31}\u{27}", &["\u{5f}\u{308}\u{31}",
+        "\u{27}"]), ("\u{5f}\u{31}\u{2c}", &["\u{5f}\u{31}", "\u{2c}"]),
+        ("\u{5f}\u{308}\u{31}\u{2c}", &["\u{5f}\u{308}\u{31}", "\u{2c}"]),
+        ("\u{5f}\u{31}\u{2e}\u{2060}", &["\u{5f}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{5f}\u{308}\u{31}\u{2e}\u{2060}", &["\u{5f}\u{308}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1f1e6}\u{1}", &["\u{1f1e6}", "\u{1}"]), ("\u{1f1e6}\u{308}\u{1}", &["\u{1f1e6}\u{308}",
+        "\u{1}"]), ("\u{1f1e6}\u{d}", &["\u{1f1e6}", "\u{d}"]), ("\u{1f1e6}\u{308}\u{d}",
+        &["\u{1f1e6}\u{308}", "\u{d}"]), ("\u{1f1e6}\u{a}", &["\u{1f1e6}", "\u{a}"]),
+        ("\u{1f1e6}\u{308}\u{a}", &["\u{1f1e6}\u{308}", "\u{a}"]), ("\u{1f1e6}\u{b}", &["\u{1f1e6}",
+        "\u{b}"]), ("\u{1f1e6}\u{308}\u{b}", &["\u{1f1e6}\u{308}", "\u{b}"]), ("\u{1f1e6}\u{3031}",
+        &["\u{1f1e6}", "\u{3031}"]), ("\u{1f1e6}\u{308}\u{3031}", &["\u{1f1e6}\u{308}",
+        "\u{3031}"]), ("\u{1f1e6}\u{41}", &["\u{1f1e6}", "\u{41}"]), ("\u{1f1e6}\u{308}\u{41}",
+        &["\u{1f1e6}\u{308}", "\u{41}"]), ("\u{1f1e6}\u{3a}", &["\u{1f1e6}", "\u{3a}"]),
+        ("\u{1f1e6}\u{308}\u{3a}", &["\u{1f1e6}\u{308}", "\u{3a}"]), ("\u{1f1e6}\u{2c}",
+        &["\u{1f1e6}", "\u{2c}"]), ("\u{1f1e6}\u{308}\u{2c}", &["\u{1f1e6}\u{308}", "\u{2c}"]),
+        ("\u{1f1e6}\u{2e}", &["\u{1f1e6}", "\u{2e}"]), ("\u{1f1e6}\u{308}\u{2e}",
+        &["\u{1f1e6}\u{308}", "\u{2e}"]), ("\u{1f1e6}\u{30}", &["\u{1f1e6}", "\u{30}"]),
+        ("\u{1f1e6}\u{308}\u{30}", &["\u{1f1e6}\u{308}", "\u{30}"]), ("\u{1f1e6}\u{5f}",
+        &["\u{1f1e6}", "\u{5f}"]), ("\u{1f1e6}\u{308}\u{5f}", &["\u{1f1e6}\u{308}", "\u{5f}"]),
+        ("\u{1f1e6}\u{1f1e6}", &["\u{1f1e6}\u{1f1e6}"]), ("\u{1f1e6}\u{308}\u{1f1e6}",
+        &["\u{1f1e6}\u{308}\u{1f1e6}"]), ("\u{1f1e6}\u{5d0}", &["\u{1f1e6}", "\u{5d0}"]),
+        ("\u{1f1e6}\u{308}\u{5d0}", &["\u{1f1e6}\u{308}", "\u{5d0}"]), ("\u{1f1e6}\u{22}",
+        &["\u{1f1e6}", "\u{22}"]), ("\u{1f1e6}\u{308}\u{22}", &["\u{1f1e6}\u{308}", "\u{22}"]),
+        ("\u{1f1e6}\u{27}", &["\u{1f1e6}", "\u{27}"]), ("\u{1f1e6}\u{308}\u{27}",
+        &["\u{1f1e6}\u{308}", "\u{27}"]), ("\u{1f1e6}\u{261d}", &["\u{1f1e6}", "\u{261d}"]),
+        ("\u{1f1e6}\u{308}\u{261d}", &["\u{1f1e6}\u{308}", "\u{261d}"]), ("\u{1f1e6}\u{1f3fb}",
+        &["\u{1f1e6}", "\u{1f3fb}"]), ("\u{1f1e6}\u{308}\u{1f3fb}", &["\u{1f1e6}\u{308}",
+        "\u{1f3fb}"]), ("\u{1f1e6}\u{2764}", &["\u{1f1e6}", "\u{2764}"]),
+        ("\u{1f1e6}\u{308}\u{2764}", &["\u{1f1e6}\u{308}", "\u{2764}"]), ("\u{1f1e6}\u{1f466}",
+        &["\u{1f1e6}", "\u{1f466}"]), ("\u{1f1e6}\u{308}\u{1f466}", &["\u{1f1e6}\u{308}",
+        "\u{1f466}"]), ("\u{1f1e6}\u{ad}", &["\u{1f1e6}\u{ad}"]), ("\u{1f1e6}\u{308}\u{ad}",
+        &["\u{1f1e6}\u{308}\u{ad}"]), ("\u{1f1e6}\u{300}", &["\u{1f1e6}\u{300}"]),
+        ("\u{1f1e6}\u{308}\u{300}", &["\u{1f1e6}\u{308}\u{300}"]), ("\u{1f1e6}\u{200d}",
+        &["\u{1f1e6}\u{200d}"]), ("\u{1f1e6}\u{308}\u{200d}", &["\u{1f1e6}\u{308}\u{200d}"]),
+        ("\u{1f1e6}\u{61}\u{2060}", &["\u{1f1e6}", "\u{61}\u{2060}"]),
+        ("\u{1f1e6}\u{308}\u{61}\u{2060}", &["\u{1f1e6}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{1f1e6}\u{61}\u{3a}", &["\u{1f1e6}", "\u{61}", "\u{3a}"]),
+        ("\u{1f1e6}\u{308}\u{61}\u{3a}", &["\u{1f1e6}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{1f1e6}\u{61}\u{27}", &["\u{1f1e6}", "\u{61}", "\u{27}"]),
+        ("\u{1f1e6}\u{308}\u{61}\u{27}", &["\u{1f1e6}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{1f1e6}\u{61}\u{27}\u{2060}", &["\u{1f1e6}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1f1e6}\u{308}\u{61}\u{27}\u{2060}", &["\u{1f1e6}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1f1e6}\u{61}\u{2c}", &["\u{1f1e6}", "\u{61}", "\u{2c}"]),
+        ("\u{1f1e6}\u{308}\u{61}\u{2c}", &["\u{1f1e6}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{1f1e6}\u{31}\u{3a}", &["\u{1f1e6}", "\u{31}", "\u{3a}"]),
+        ("\u{1f1e6}\u{308}\u{31}\u{3a}", &["\u{1f1e6}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{1f1e6}\u{31}\u{27}", &["\u{1f1e6}", "\u{31}", "\u{27}"]),
+        ("\u{1f1e6}\u{308}\u{31}\u{27}", &["\u{1f1e6}\u{308}", "\u{31}", "\u{27}"]),
+        ("\u{1f1e6}\u{31}\u{2c}", &["\u{1f1e6}", "\u{31}", "\u{2c}"]),
+        ("\u{1f1e6}\u{308}\u{31}\u{2c}", &["\u{1f1e6}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{1f1e6}\u{31}\u{2e}\u{2060}", &["\u{1f1e6}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1f1e6}\u{308}\u{31}\u{2e}\u{2060}", &["\u{1f1e6}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{5d0}\u{1}", &["\u{5d0}", "\u{1}"]), ("\u{5d0}\u{308}\u{1}", &["\u{5d0}\u{308}",
+        "\u{1}"]), ("\u{5d0}\u{d}", &["\u{5d0}", "\u{d}"]), ("\u{5d0}\u{308}\u{d}",
+        &["\u{5d0}\u{308}", "\u{d}"]), ("\u{5d0}\u{a}", &["\u{5d0}", "\u{a}"]),
+        ("\u{5d0}\u{308}\u{a}", &["\u{5d0}\u{308}", "\u{a}"]), ("\u{5d0}\u{b}", &["\u{5d0}",
+        "\u{b}"]), ("\u{5d0}\u{308}\u{b}", &["\u{5d0}\u{308}", "\u{b}"]), ("\u{5d0}\u{3031}",
+        &["\u{5d0}", "\u{3031}"]), ("\u{5d0}\u{308}\u{3031}", &["\u{5d0}\u{308}", "\u{3031}"]),
+        ("\u{5d0}\u{41}", &["\u{5d0}\u{41}"]), ("\u{5d0}\u{308}\u{41}", &["\u{5d0}\u{308}\u{41}"]),
+        ("\u{5d0}\u{3a}", &["\u{5d0}", "\u{3a}"]), ("\u{5d0}\u{308}\u{3a}", &["\u{5d0}\u{308}",
+        "\u{3a}"]), ("\u{5d0}\u{2c}", &["\u{5d0}", "\u{2c}"]), ("\u{5d0}\u{308}\u{2c}",
+        &["\u{5d0}\u{308}", "\u{2c}"]), ("\u{5d0}\u{2e}", &["\u{5d0}", "\u{2e}"]),
+        ("\u{5d0}\u{308}\u{2e}", &["\u{5d0}\u{308}", "\u{2e}"]), ("\u{5d0}\u{30}",
+        &["\u{5d0}\u{30}"]), ("\u{5d0}\u{308}\u{30}", &["\u{5d0}\u{308}\u{30}"]), ("\u{5d0}\u{5f}",
+        &["\u{5d0}\u{5f}"]), ("\u{5d0}\u{308}\u{5f}", &["\u{5d0}\u{308}\u{5f}"]),
+        ("\u{5d0}\u{1f1e6}", &["\u{5d0}", "\u{1f1e6}"]), ("\u{5d0}\u{308}\u{1f1e6}",
+        &["\u{5d0}\u{308}", "\u{1f1e6}"]), ("\u{5d0}\u{5d0}", &["\u{5d0}\u{5d0}"]),
+        ("\u{5d0}\u{308}\u{5d0}", &["\u{5d0}\u{308}\u{5d0}"]), ("\u{5d0}\u{22}", &["\u{5d0}",
+        "\u{22}"]), ("\u{5d0}\u{308}\u{22}", &["\u{5d0}\u{308}", "\u{22}"]), ("\u{5d0}\u{27}",
+        &["\u{5d0}\u{27}"]), ("\u{5d0}\u{308}\u{27}", &["\u{5d0}\u{308}\u{27}"]),
+        ("\u{5d0}\u{261d}", &["\u{5d0}", "\u{261d}"]), ("\u{5d0}\u{308}\u{261d}",
+        &["\u{5d0}\u{308}", "\u{261d}"]), ("\u{5d0}\u{1f3fb}", &["\u{5d0}", "\u{1f3fb}"]),
+        ("\u{5d0}\u{308}\u{1f3fb}", &["\u{5d0}\u{308}", "\u{1f3fb}"]), ("\u{5d0}\u{2764}",
+        &["\u{5d0}", "\u{2764}"]), ("\u{5d0}\u{308}\u{2764}", &["\u{5d0}\u{308}", "\u{2764}"]),
+        ("\u{5d0}\u{1f466}", &["\u{5d0}", "\u{1f466}"]), ("\u{5d0}\u{308}\u{1f466}",
+        &["\u{5d0}\u{308}", "\u{1f466}"]), ("\u{5d0}\u{ad}", &["\u{5d0}\u{ad}"]),
+        ("\u{5d0}\u{308}\u{ad}", &["\u{5d0}\u{308}\u{ad}"]), ("\u{5d0}\u{300}",
+        &["\u{5d0}\u{300}"]), ("\u{5d0}\u{308}\u{300}", &["\u{5d0}\u{308}\u{300}"]),
+        ("\u{5d0}\u{200d}", &["\u{5d0}\u{200d}"]), ("\u{5d0}\u{308}\u{200d}",
+        &["\u{5d0}\u{308}\u{200d}"]), ("\u{5d0}\u{61}\u{2060}", &["\u{5d0}\u{61}\u{2060}"]),
+        ("\u{5d0}\u{308}\u{61}\u{2060}", &["\u{5d0}\u{308}\u{61}\u{2060}"]), ("\u{5d0}\u{61}\u{3a}",
+        &["\u{5d0}\u{61}", "\u{3a}"]), ("\u{5d0}\u{308}\u{61}\u{3a}", &["\u{5d0}\u{308}\u{61}",
+        "\u{3a}"]), ("\u{5d0}\u{61}\u{27}", &["\u{5d0}\u{61}", "\u{27}"]),
+        ("\u{5d0}\u{308}\u{61}\u{27}", &["\u{5d0}\u{308}\u{61}", "\u{27}"]),
+        ("\u{5d0}\u{61}\u{27}\u{2060}", &["\u{5d0}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{5d0}\u{308}\u{61}\u{27}\u{2060}", &["\u{5d0}\u{308}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{5d0}\u{61}\u{2c}", &["\u{5d0}\u{61}", "\u{2c}"]), ("\u{5d0}\u{308}\u{61}\u{2c}",
+        &["\u{5d0}\u{308}\u{61}", "\u{2c}"]), ("\u{5d0}\u{31}\u{3a}", &["\u{5d0}\u{31}", "\u{3a}"]),
+        ("\u{5d0}\u{308}\u{31}\u{3a}", &["\u{5d0}\u{308}\u{31}", "\u{3a}"]), ("\u{5d0}\u{31}\u{27}",
+        &["\u{5d0}\u{31}", "\u{27}"]), ("\u{5d0}\u{308}\u{31}\u{27}", &["\u{5d0}\u{308}\u{31}",
+        "\u{27}"]), ("\u{5d0}\u{31}\u{2c}", &["\u{5d0}\u{31}", "\u{2c}"]),
+        ("\u{5d0}\u{308}\u{31}\u{2c}", &["\u{5d0}\u{308}\u{31}", "\u{2c}"]),
+        ("\u{5d0}\u{31}\u{2e}\u{2060}", &["\u{5d0}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{5d0}\u{308}\u{31}\u{2e}\u{2060}", &["\u{5d0}\u{308}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{22}\u{1}", &["\u{22}", "\u{1}"]), ("\u{22}\u{308}\u{1}", &["\u{22}\u{308}", "\u{1}"]),
+        ("\u{22}\u{d}", &["\u{22}", "\u{d}"]), ("\u{22}\u{308}\u{d}", &["\u{22}\u{308}", "\u{d}"]),
+        ("\u{22}\u{a}", &["\u{22}", "\u{a}"]), ("\u{22}\u{308}\u{a}", &["\u{22}\u{308}", "\u{a}"]),
+        ("\u{22}\u{b}", &["\u{22}", "\u{b}"]), ("\u{22}\u{308}\u{b}", &["\u{22}\u{308}", "\u{b}"]),
+        ("\u{22}\u{3031}", &["\u{22}", "\u{3031}"]), ("\u{22}\u{308}\u{3031}", &["\u{22}\u{308}",
+        "\u{3031}"]), ("\u{22}\u{41}", &["\u{22}", "\u{41}"]), ("\u{22}\u{308}\u{41}",
+        &["\u{22}\u{308}", "\u{41}"]), ("\u{22}\u{3a}", &["\u{22}", "\u{3a}"]),
+        ("\u{22}\u{308}\u{3a}", &["\u{22}\u{308}", "\u{3a}"]), ("\u{22}\u{2c}", &["\u{22}",
+        "\u{2c}"]), ("\u{22}\u{308}\u{2c}", &["\u{22}\u{308}", "\u{2c}"]), ("\u{22}\u{2e}",
+        &["\u{22}", "\u{2e}"]), ("\u{22}\u{308}\u{2e}", &["\u{22}\u{308}", "\u{2e}"]),
+        ("\u{22}\u{30}", &["\u{22}", "\u{30}"]), ("\u{22}\u{308}\u{30}", &["\u{22}\u{308}",
+        "\u{30}"]), ("\u{22}\u{5f}", &["\u{22}", "\u{5f}"]), ("\u{22}\u{308}\u{5f}",
+        &["\u{22}\u{308}", "\u{5f}"]), ("\u{22}\u{1f1e6}", &["\u{22}", "\u{1f1e6}"]),
+        ("\u{22}\u{308}\u{1f1e6}", &["\u{22}\u{308}", "\u{1f1e6}"]), ("\u{22}\u{5d0}", &["\u{22}",
+        "\u{5d0}"]), ("\u{22}\u{308}\u{5d0}", &["\u{22}\u{308}", "\u{5d0}"]), ("\u{22}\u{22}",
+        &["\u{22}", "\u{22}"]), ("\u{22}\u{308}\u{22}", &["\u{22}\u{308}", "\u{22}"]),
+        ("\u{22}\u{27}", &["\u{22}", "\u{27}"]), ("\u{22}\u{308}\u{27}", &["\u{22}\u{308}",
+        "\u{27}"]), ("\u{22}\u{261d}", &["\u{22}", "\u{261d}"]), ("\u{22}\u{308}\u{261d}",
+        &["\u{22}\u{308}", "\u{261d}"]), ("\u{22}\u{1f3fb}", &["\u{22}", "\u{1f3fb}"]),
+        ("\u{22}\u{308}\u{1f3fb}", &["\u{22}\u{308}", "\u{1f3fb}"]), ("\u{22}\u{2764}", &["\u{22}",
+        "\u{2764}"]), ("\u{22}\u{308}\u{2764}", &["\u{22}\u{308}", "\u{2764}"]), ("\u{22}\u{1f466}",
+        &["\u{22}", "\u{1f466}"]), ("\u{22}\u{308}\u{1f466}", &["\u{22}\u{308}", "\u{1f466}"]),
+        ("\u{22}\u{ad}", &["\u{22}\u{ad}"]), ("\u{22}\u{308}\u{ad}", &["\u{22}\u{308}\u{ad}"]),
+        ("\u{22}\u{300}", &["\u{22}\u{300}"]), ("\u{22}\u{308}\u{300}", &["\u{22}\u{308}\u{300}"]),
+        ("\u{22}\u{200d}", &["\u{22}\u{200d}"]), ("\u{22}\u{308}\u{200d}",
+        &["\u{22}\u{308}\u{200d}"]), ("\u{22}\u{61}\u{2060}", &["\u{22}", "\u{61}\u{2060}"]),
+        ("\u{22}\u{308}\u{61}\u{2060}", &["\u{22}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{22}\u{61}\u{3a}", &["\u{22}", "\u{61}", "\u{3a}"]), ("\u{22}\u{308}\u{61}\u{3a}",
+        &["\u{22}\u{308}", "\u{61}", "\u{3a}"]), ("\u{22}\u{61}\u{27}", &["\u{22}", "\u{61}",
+        "\u{27}"]), ("\u{22}\u{308}\u{61}\u{27}", &["\u{22}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{22}\u{61}\u{27}\u{2060}", &["\u{22}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{22}\u{308}\u{61}\u{27}\u{2060}", &["\u{22}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{22}\u{61}\u{2c}", &["\u{22}", "\u{61}", "\u{2c}"]), ("\u{22}\u{308}\u{61}\u{2c}",
+        &["\u{22}\u{308}", "\u{61}", "\u{2c}"]), ("\u{22}\u{31}\u{3a}", &["\u{22}", "\u{31}",
+        "\u{3a}"]), ("\u{22}\u{308}\u{31}\u{3a}", &["\u{22}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{22}\u{31}\u{27}", &["\u{22}", "\u{31}", "\u{27}"]), ("\u{22}\u{308}\u{31}\u{27}",
+        &["\u{22}\u{308}", "\u{31}", "\u{27}"]), ("\u{22}\u{31}\u{2c}", &["\u{22}", "\u{31}",
+        "\u{2c}"]), ("\u{22}\u{308}\u{31}\u{2c}", &["\u{22}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{22}\u{31}\u{2e}\u{2060}", &["\u{22}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{22}\u{308}\u{31}\u{2e}\u{2060}", &["\u{22}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{27}\u{1}", &["\u{27}", "\u{1}"]), ("\u{27}\u{308}\u{1}", &["\u{27}\u{308}", "\u{1}"]),
+        ("\u{27}\u{d}", &["\u{27}", "\u{d}"]), ("\u{27}\u{308}\u{d}", &["\u{27}\u{308}", "\u{d}"]),
+        ("\u{27}\u{a}", &["\u{27}", "\u{a}"]), ("\u{27}\u{308}\u{a}", &["\u{27}\u{308}", "\u{a}"]),
+        ("\u{27}\u{b}", &["\u{27}", "\u{b}"]), ("\u{27}\u{308}\u{b}", &["\u{27}\u{308}", "\u{b}"]),
+        ("\u{27}\u{3031}", &["\u{27}", "\u{3031}"]), ("\u{27}\u{308}\u{3031}", &["\u{27}\u{308}",
+        "\u{3031}"]), ("\u{27}\u{41}", &["\u{27}", "\u{41}"]), ("\u{27}\u{308}\u{41}",
+        &["\u{27}\u{308}", "\u{41}"]), ("\u{27}\u{3a}", &["\u{27}", "\u{3a}"]),
+        ("\u{27}\u{308}\u{3a}", &["\u{27}\u{308}", "\u{3a}"]), ("\u{27}\u{2c}", &["\u{27}",
+        "\u{2c}"]), ("\u{27}\u{308}\u{2c}", &["\u{27}\u{308}", "\u{2c}"]), ("\u{27}\u{2e}",
+        &["\u{27}", "\u{2e}"]), ("\u{27}\u{308}\u{2e}", &["\u{27}\u{308}", "\u{2e}"]),
+        ("\u{27}\u{30}", &["\u{27}", "\u{30}"]), ("\u{27}\u{308}\u{30}", &["\u{27}\u{308}",
+        "\u{30}"]), ("\u{27}\u{5f}", &["\u{27}", "\u{5f}"]), ("\u{27}\u{308}\u{5f}",
+        &["\u{27}\u{308}", "\u{5f}"]), ("\u{27}\u{1f1e6}", &["\u{27}", "\u{1f1e6}"]),
+        ("\u{27}\u{308}\u{1f1e6}", &["\u{27}\u{308}", "\u{1f1e6}"]), ("\u{27}\u{5d0}", &["\u{27}",
+        "\u{5d0}"]), ("\u{27}\u{308}\u{5d0}", &["\u{27}\u{308}", "\u{5d0}"]), ("\u{27}\u{22}",
+        &["\u{27}", "\u{22}"]), ("\u{27}\u{308}\u{22}", &["\u{27}\u{308}", "\u{22}"]),
+        ("\u{27}\u{27}", &["\u{27}", "\u{27}"]), ("\u{27}\u{308}\u{27}", &["\u{27}\u{308}",
+        "\u{27}"]), ("\u{27}\u{261d}", &["\u{27}", "\u{261d}"]), ("\u{27}\u{308}\u{261d}",
+        &["\u{27}\u{308}", "\u{261d}"]), ("\u{27}\u{1f3fb}", &["\u{27}", "\u{1f3fb}"]),
+        ("\u{27}\u{308}\u{1f3fb}", &["\u{27}\u{308}", "\u{1f3fb}"]), ("\u{27}\u{2764}", &["\u{27}",
+        "\u{2764}"]), ("\u{27}\u{308}\u{2764}", &["\u{27}\u{308}", "\u{2764}"]), ("\u{27}\u{1f466}",
+        &["\u{27}", "\u{1f466}"]), ("\u{27}\u{308}\u{1f466}", &["\u{27}\u{308}", "\u{1f466}"]),
+        ("\u{27}\u{ad}", &["\u{27}\u{ad}"]), ("\u{27}\u{308}\u{ad}", &["\u{27}\u{308}\u{ad}"]),
+        ("\u{27}\u{300}", &["\u{27}\u{300}"]), ("\u{27}\u{308}\u{300}", &["\u{27}\u{308}\u{300}"]),
+        ("\u{27}\u{200d}", &["\u{27}\u{200d}"]), ("\u{27}\u{308}\u{200d}",
+        &["\u{27}\u{308}\u{200d}"]), ("\u{27}\u{61}\u{2060}", &["\u{27}", "\u{61}\u{2060}"]),
+        ("\u{27}\u{308}\u{61}\u{2060}", &["\u{27}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{27}\u{61}\u{3a}", &["\u{27}", "\u{61}", "\u{3a}"]), ("\u{27}\u{308}\u{61}\u{3a}",
+        &["\u{27}\u{308}", "\u{61}", "\u{3a}"]), ("\u{27}\u{61}\u{27}", &["\u{27}", "\u{61}",
+        "\u{27}"]), ("\u{27}\u{308}\u{61}\u{27}", &["\u{27}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{27}\u{61}\u{27}\u{2060}", &["\u{27}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{27}\u{308}\u{61}\u{27}\u{2060}", &["\u{27}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{27}\u{61}\u{2c}", &["\u{27}", "\u{61}", "\u{2c}"]), ("\u{27}\u{308}\u{61}\u{2c}",
+        &["\u{27}\u{308}", "\u{61}", "\u{2c}"]), ("\u{27}\u{31}\u{3a}", &["\u{27}", "\u{31}",
+        "\u{3a}"]), ("\u{27}\u{308}\u{31}\u{3a}", &["\u{27}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{27}\u{31}\u{27}", &["\u{27}", "\u{31}", "\u{27}"]), ("\u{27}\u{308}\u{31}\u{27}",
+        &["\u{27}\u{308}", "\u{31}", "\u{27}"]), ("\u{27}\u{31}\u{2c}", &["\u{27}", "\u{31}",
+        "\u{2c}"]), ("\u{27}\u{308}\u{31}\u{2c}", &["\u{27}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{27}\u{31}\u{2e}\u{2060}", &["\u{27}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{27}\u{308}\u{31}\u{2e}\u{2060}", &["\u{27}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{261d}\u{1}", &["\u{261d}", "\u{1}"]), ("\u{261d}\u{308}\u{1}", &["\u{261d}\u{308}",
+        "\u{1}"]), ("\u{261d}\u{d}", &["\u{261d}", "\u{d}"]), ("\u{261d}\u{308}\u{d}",
+        &["\u{261d}\u{308}", "\u{d}"]), ("\u{261d}\u{a}", &["\u{261d}", "\u{a}"]),
+        ("\u{261d}\u{308}\u{a}", &["\u{261d}\u{308}", "\u{a}"]), ("\u{261d}\u{b}", &["\u{261d}",
+        "\u{b}"]), ("\u{261d}\u{308}\u{b}", &["\u{261d}\u{308}", "\u{b}"]), ("\u{261d}\u{3031}",
+        &["\u{261d}", "\u{3031}"]), ("\u{261d}\u{308}\u{3031}", &["\u{261d}\u{308}", "\u{3031}"]),
+        ("\u{261d}\u{41}", &["\u{261d}", "\u{41}"]), ("\u{261d}\u{308}\u{41}", &["\u{261d}\u{308}",
+        "\u{41}"]), ("\u{261d}\u{3a}", &["\u{261d}", "\u{3a}"]), ("\u{261d}\u{308}\u{3a}",
+        &["\u{261d}\u{308}", "\u{3a}"]), ("\u{261d}\u{2c}", &["\u{261d}", "\u{2c}"]),
+        ("\u{261d}\u{308}\u{2c}", &["\u{261d}\u{308}", "\u{2c}"]), ("\u{261d}\u{2e}", &["\u{261d}",
+        "\u{2e}"]), ("\u{261d}\u{308}\u{2e}", &["\u{261d}\u{308}", "\u{2e}"]), ("\u{261d}\u{30}",
+        &["\u{261d}", "\u{30}"]), ("\u{261d}\u{308}\u{30}", &["\u{261d}\u{308}", "\u{30}"]),
+        ("\u{261d}\u{5f}", &["\u{261d}", "\u{5f}"]), ("\u{261d}\u{308}\u{5f}", &["\u{261d}\u{308}",
+        "\u{5f}"]), ("\u{261d}\u{1f1e6}", &["\u{261d}", "\u{1f1e6}"]), ("\u{261d}\u{308}\u{1f1e6}",
+        &["\u{261d}\u{308}", "\u{1f1e6}"]), ("\u{261d}\u{5d0}", &["\u{261d}", "\u{5d0}"]),
+        ("\u{261d}\u{308}\u{5d0}", &["\u{261d}\u{308}", "\u{5d0}"]), ("\u{261d}\u{22}",
+        &["\u{261d}", "\u{22}"]), ("\u{261d}\u{308}\u{22}", &["\u{261d}\u{308}", "\u{22}"]),
+        ("\u{261d}\u{27}", &["\u{261d}", "\u{27}"]), ("\u{261d}\u{308}\u{27}", &["\u{261d}\u{308}",
+        "\u{27}"]), ("\u{261d}\u{261d}", &["\u{261d}", "\u{261d}"]), ("\u{261d}\u{308}\u{261d}",
+        &["\u{261d}\u{308}", "\u{261d}"]), ("\u{261d}\u{1f3fb}", &["\u{261d}\u{1f3fb}"]),
+        ("\u{261d}\u{308}\u{1f3fb}", &["\u{261d}\u{308}\u{1f3fb}"]), ("\u{261d}\u{2764}",
+        &["\u{261d}", "\u{2764}"]), ("\u{261d}\u{308}\u{2764}", &["\u{261d}\u{308}", "\u{2764}"]),
+        ("\u{261d}\u{1f466}", &["\u{261d}", "\u{1f466}"]), ("\u{261d}\u{308}\u{1f466}",
+        &["\u{261d}\u{308}", "\u{1f466}"]), ("\u{261d}\u{ad}", &["\u{261d}\u{ad}"]),
+        ("\u{261d}\u{308}\u{ad}", &["\u{261d}\u{308}\u{ad}"]), ("\u{261d}\u{300}",
+        &["\u{261d}\u{300}"]), ("\u{261d}\u{308}\u{300}", &["\u{261d}\u{308}\u{300}"]),
+        ("\u{261d}\u{200d}", &["\u{261d}\u{200d}"]), ("\u{261d}\u{308}\u{200d}",
+        &["\u{261d}\u{308}\u{200d}"]), ("\u{261d}\u{61}\u{2060}", &["\u{261d}", "\u{61}\u{2060}"]),
+        ("\u{261d}\u{308}\u{61}\u{2060}", &["\u{261d}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{261d}\u{61}\u{3a}", &["\u{261d}", "\u{61}", "\u{3a}"]), ("\u{261d}\u{308}\u{61}\u{3a}",
+        &["\u{261d}\u{308}", "\u{61}", "\u{3a}"]), ("\u{261d}\u{61}\u{27}", &["\u{261d}", "\u{61}",
+        "\u{27}"]), ("\u{261d}\u{308}\u{61}\u{27}", &["\u{261d}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{261d}\u{61}\u{27}\u{2060}", &["\u{261d}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{261d}\u{308}\u{61}\u{27}\u{2060}", &["\u{261d}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{261d}\u{61}\u{2c}", &["\u{261d}", "\u{61}", "\u{2c}"]), ("\u{261d}\u{308}\u{61}\u{2c}",
+        &["\u{261d}\u{308}", "\u{61}", "\u{2c}"]), ("\u{261d}\u{31}\u{3a}", &["\u{261d}", "\u{31}",
+        "\u{3a}"]), ("\u{261d}\u{308}\u{31}\u{3a}", &["\u{261d}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{261d}\u{31}\u{27}", &["\u{261d}", "\u{31}", "\u{27}"]), ("\u{261d}\u{308}\u{31}\u{27}",
+        &["\u{261d}\u{308}", "\u{31}", "\u{27}"]), ("\u{261d}\u{31}\u{2c}", &["\u{261d}", "\u{31}",
+        "\u{2c}"]), ("\u{261d}\u{308}\u{31}\u{2c}", &["\u{261d}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{261d}\u{31}\u{2e}\u{2060}", &["\u{261d}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{261d}\u{308}\u{31}\u{2e}\u{2060}", &["\u{261d}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1f3fb}\u{1}", &["\u{1f3fb}", "\u{1}"]), ("\u{1f3fb}\u{308}\u{1}", &["\u{1f3fb}\u{308}",
+        "\u{1}"]), ("\u{1f3fb}\u{d}", &["\u{1f3fb}", "\u{d}"]), ("\u{1f3fb}\u{308}\u{d}",
+        &["\u{1f3fb}\u{308}", "\u{d}"]), ("\u{1f3fb}\u{a}", &["\u{1f3fb}", "\u{a}"]),
+        ("\u{1f3fb}\u{308}\u{a}", &["\u{1f3fb}\u{308}", "\u{a}"]), ("\u{1f3fb}\u{b}", &["\u{1f3fb}",
+        "\u{b}"]), ("\u{1f3fb}\u{308}\u{b}", &["\u{1f3fb}\u{308}", "\u{b}"]), ("\u{1f3fb}\u{3031}",
+        &["\u{1f3fb}", "\u{3031}"]), ("\u{1f3fb}\u{308}\u{3031}", &["\u{1f3fb}\u{308}",
+        "\u{3031}"]), ("\u{1f3fb}\u{41}", &["\u{1f3fb}", "\u{41}"]), ("\u{1f3fb}\u{308}\u{41}",
+        &["\u{1f3fb}\u{308}", "\u{41}"]), ("\u{1f3fb}\u{3a}", &["\u{1f3fb}", "\u{3a}"]),
+        ("\u{1f3fb}\u{308}\u{3a}", &["\u{1f3fb}\u{308}", "\u{3a}"]), ("\u{1f3fb}\u{2c}",
+        &["\u{1f3fb}", "\u{2c}"]), ("\u{1f3fb}\u{308}\u{2c}", &["\u{1f3fb}\u{308}", "\u{2c}"]),
+        ("\u{1f3fb}\u{2e}", &["\u{1f3fb}", "\u{2e}"]), ("\u{1f3fb}\u{308}\u{2e}",
+        &["\u{1f3fb}\u{308}", "\u{2e}"]), ("\u{1f3fb}\u{30}", &["\u{1f3fb}", "\u{30}"]),
+        ("\u{1f3fb}\u{308}\u{30}", &["\u{1f3fb}\u{308}", "\u{30}"]), ("\u{1f3fb}\u{5f}",
+        &["\u{1f3fb}", "\u{5f}"]), ("\u{1f3fb}\u{308}\u{5f}", &["\u{1f3fb}\u{308}", "\u{5f}"]),
+        ("\u{1f3fb}\u{1f1e6}", &["\u{1f3fb}", "\u{1f1e6}"]), ("\u{1f3fb}\u{308}\u{1f1e6}",
+        &["\u{1f3fb}\u{308}", "\u{1f1e6}"]), ("\u{1f3fb}\u{5d0}", &["\u{1f3fb}", "\u{5d0}"]),
+        ("\u{1f3fb}\u{308}\u{5d0}", &["\u{1f3fb}\u{308}", "\u{5d0}"]), ("\u{1f3fb}\u{22}",
+        &["\u{1f3fb}", "\u{22}"]), ("\u{1f3fb}\u{308}\u{22}", &["\u{1f3fb}\u{308}", "\u{22}"]),
+        ("\u{1f3fb}\u{27}", &["\u{1f3fb}", "\u{27}"]), ("\u{1f3fb}\u{308}\u{27}",
+        &["\u{1f3fb}\u{308}", "\u{27}"]), ("\u{1f3fb}\u{261d}", &["\u{1f3fb}", "\u{261d}"]),
+        ("\u{1f3fb}\u{308}\u{261d}", &["\u{1f3fb}\u{308}", "\u{261d}"]), ("\u{1f3fb}\u{1f3fb}",
+        &["\u{1f3fb}", "\u{1f3fb}"]), ("\u{1f3fb}\u{308}\u{1f3fb}", &["\u{1f3fb}\u{308}",
+        "\u{1f3fb}"]), ("\u{1f3fb}\u{2764}", &["\u{1f3fb}", "\u{2764}"]),
+        ("\u{1f3fb}\u{308}\u{2764}", &["\u{1f3fb}\u{308}", "\u{2764}"]), ("\u{1f3fb}\u{1f466}",
+        &["\u{1f3fb}", "\u{1f466}"]), ("\u{1f3fb}\u{308}\u{1f466}", &["\u{1f3fb}\u{308}",
+        "\u{1f466}"]), ("\u{1f3fb}\u{ad}", &["\u{1f3fb}\u{ad}"]), ("\u{1f3fb}\u{308}\u{ad}",
+        &["\u{1f3fb}\u{308}\u{ad}"]), ("\u{1f3fb}\u{300}", &["\u{1f3fb}\u{300}"]),
+        ("\u{1f3fb}\u{308}\u{300}", &["\u{1f3fb}\u{308}\u{300}"]), ("\u{1f3fb}\u{200d}",
+        &["\u{1f3fb}\u{200d}"]), ("\u{1f3fb}\u{308}\u{200d}", &["\u{1f3fb}\u{308}\u{200d}"]),
+        ("\u{1f3fb}\u{61}\u{2060}", &["\u{1f3fb}", "\u{61}\u{2060}"]),
+        ("\u{1f3fb}\u{308}\u{61}\u{2060}", &["\u{1f3fb}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{1f3fb}\u{61}\u{3a}", &["\u{1f3fb}", "\u{61}", "\u{3a}"]),
+        ("\u{1f3fb}\u{308}\u{61}\u{3a}", &["\u{1f3fb}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{1f3fb}\u{61}\u{27}", &["\u{1f3fb}", "\u{61}", "\u{27}"]),
+        ("\u{1f3fb}\u{308}\u{61}\u{27}", &["\u{1f3fb}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{1f3fb}\u{61}\u{27}\u{2060}", &["\u{1f3fb}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1f3fb}\u{308}\u{61}\u{27}\u{2060}", &["\u{1f3fb}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1f3fb}\u{61}\u{2c}", &["\u{1f3fb}", "\u{61}", "\u{2c}"]),
+        ("\u{1f3fb}\u{308}\u{61}\u{2c}", &["\u{1f3fb}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{1f3fb}\u{31}\u{3a}", &["\u{1f3fb}", "\u{31}", "\u{3a}"]),
+        ("\u{1f3fb}\u{308}\u{31}\u{3a}", &["\u{1f3fb}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{1f3fb}\u{31}\u{27}", &["\u{1f3fb}", "\u{31}", "\u{27}"]),
+        ("\u{1f3fb}\u{308}\u{31}\u{27}", &["\u{1f3fb}\u{308}", "\u{31}", "\u{27}"]),
+        ("\u{1f3fb}\u{31}\u{2c}", &["\u{1f3fb}", "\u{31}", "\u{2c}"]),
+        ("\u{1f3fb}\u{308}\u{31}\u{2c}", &["\u{1f3fb}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{1f3fb}\u{31}\u{2e}\u{2060}", &["\u{1f3fb}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1f3fb}\u{308}\u{31}\u{2e}\u{2060}", &["\u{1f3fb}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{2764}\u{1}", &["\u{2764}", "\u{1}"]), ("\u{2764}\u{308}\u{1}", &["\u{2764}\u{308}",
+        "\u{1}"]), ("\u{2764}\u{d}", &["\u{2764}", "\u{d}"]), ("\u{2764}\u{308}\u{d}",
+        &["\u{2764}\u{308}", "\u{d}"]), ("\u{2764}\u{a}", &["\u{2764}", "\u{a}"]),
+        ("\u{2764}\u{308}\u{a}", &["\u{2764}\u{308}", "\u{a}"]), ("\u{2764}\u{b}", &["\u{2764}",
+        "\u{b}"]), ("\u{2764}\u{308}\u{b}", &["\u{2764}\u{308}", "\u{b}"]), ("\u{2764}\u{3031}",
+        &["\u{2764}", "\u{3031}"]), ("\u{2764}\u{308}\u{3031}", &["\u{2764}\u{308}", "\u{3031}"]),
+        ("\u{2764}\u{41}", &["\u{2764}", "\u{41}"]), ("\u{2764}\u{308}\u{41}", &["\u{2764}\u{308}",
+        "\u{41}"]), ("\u{2764}\u{3a}", &["\u{2764}", "\u{3a}"]), ("\u{2764}\u{308}\u{3a}",
+        &["\u{2764}\u{308}", "\u{3a}"]), ("\u{2764}\u{2c}", &["\u{2764}", "\u{2c}"]),
+        ("\u{2764}\u{308}\u{2c}", &["\u{2764}\u{308}", "\u{2c}"]), ("\u{2764}\u{2e}", &["\u{2764}",
+        "\u{2e}"]), ("\u{2764}\u{308}\u{2e}", &["\u{2764}\u{308}", "\u{2e}"]), ("\u{2764}\u{30}",
+        &["\u{2764}", "\u{30}"]), ("\u{2764}\u{308}\u{30}", &["\u{2764}\u{308}", "\u{30}"]),
+        ("\u{2764}\u{5f}", &["\u{2764}", "\u{5f}"]), ("\u{2764}\u{308}\u{5f}", &["\u{2764}\u{308}",
+        "\u{5f}"]), ("\u{2764}\u{1f1e6}", &["\u{2764}", "\u{1f1e6}"]), ("\u{2764}\u{308}\u{1f1e6}",
+        &["\u{2764}\u{308}", "\u{1f1e6}"]), ("\u{2764}\u{5d0}", &["\u{2764}", "\u{5d0}"]),
+        ("\u{2764}\u{308}\u{5d0}", &["\u{2764}\u{308}", "\u{5d0}"]), ("\u{2764}\u{22}",
+        &["\u{2764}", "\u{22}"]), ("\u{2764}\u{308}\u{22}", &["\u{2764}\u{308}", "\u{22}"]),
+        ("\u{2764}\u{27}", &["\u{2764}", "\u{27}"]), ("\u{2764}\u{308}\u{27}", &["\u{2764}\u{308}",
+        "\u{27}"]), ("\u{2764}\u{261d}", &["\u{2764}", "\u{261d}"]), ("\u{2764}\u{308}\u{261d}",
+        &["\u{2764}\u{308}", "\u{261d}"]), ("\u{2764}\u{1f3fb}", &["\u{2764}", "\u{1f3fb}"]),
+        ("\u{2764}\u{308}\u{1f3fb}", &["\u{2764}\u{308}", "\u{1f3fb}"]), ("\u{2764}\u{2764}",
+        &["\u{2764}", "\u{2764}"]), ("\u{2764}\u{308}\u{2764}", &["\u{2764}\u{308}", "\u{2764}"]),
+        ("\u{2764}\u{1f466}", &["\u{2764}", "\u{1f466}"]), ("\u{2764}\u{308}\u{1f466}",
+        &["\u{2764}\u{308}", "\u{1f466}"]), ("\u{2764}\u{ad}", &["\u{2764}\u{ad}"]),
+        ("\u{2764}\u{308}\u{ad}", &["\u{2764}\u{308}\u{ad}"]), ("\u{2764}\u{300}",
+        &["\u{2764}\u{300}"]), ("\u{2764}\u{308}\u{300}", &["\u{2764}\u{308}\u{300}"]),
+        ("\u{2764}\u{200d}", &["\u{2764}\u{200d}"]), ("\u{2764}\u{308}\u{200d}",
+        &["\u{2764}\u{308}\u{200d}"]), ("\u{2764}\u{61}\u{2060}", &["\u{2764}", "\u{61}\u{2060}"]),
+        ("\u{2764}\u{308}\u{61}\u{2060}", &["\u{2764}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{2764}\u{61}\u{3a}", &["\u{2764}", "\u{61}", "\u{3a}"]), ("\u{2764}\u{308}\u{61}\u{3a}",
+        &["\u{2764}\u{308}", "\u{61}", "\u{3a}"]), ("\u{2764}\u{61}\u{27}", &["\u{2764}", "\u{61}",
+        "\u{27}"]), ("\u{2764}\u{308}\u{61}\u{27}", &["\u{2764}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{2764}\u{61}\u{27}\u{2060}", &["\u{2764}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{2764}\u{308}\u{61}\u{27}\u{2060}", &["\u{2764}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{2764}\u{61}\u{2c}", &["\u{2764}", "\u{61}", "\u{2c}"]), ("\u{2764}\u{308}\u{61}\u{2c}",
+        &["\u{2764}\u{308}", "\u{61}", "\u{2c}"]), ("\u{2764}\u{31}\u{3a}", &["\u{2764}", "\u{31}",
+        "\u{3a}"]), ("\u{2764}\u{308}\u{31}\u{3a}", &["\u{2764}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{2764}\u{31}\u{27}", &["\u{2764}", "\u{31}", "\u{27}"]), ("\u{2764}\u{308}\u{31}\u{27}",
+        &["\u{2764}\u{308}", "\u{31}", "\u{27}"]), ("\u{2764}\u{31}\u{2c}", &["\u{2764}", "\u{31}",
+        "\u{2c}"]), ("\u{2764}\u{308}\u{31}\u{2c}", &["\u{2764}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{2764}\u{31}\u{2e}\u{2060}", &["\u{2764}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{2764}\u{308}\u{31}\u{2e}\u{2060}", &["\u{2764}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1f466}\u{1}", &["\u{1f466}", "\u{1}"]), ("\u{1f466}\u{308}\u{1}", &["\u{1f466}\u{308}",
+        "\u{1}"]), ("\u{1f466}\u{d}", &["\u{1f466}", "\u{d}"]), ("\u{1f466}\u{308}\u{d}",
+        &["\u{1f466}\u{308}", "\u{d}"]), ("\u{1f466}\u{a}", &["\u{1f466}", "\u{a}"]),
+        ("\u{1f466}\u{308}\u{a}", &["\u{1f466}\u{308}", "\u{a}"]), ("\u{1f466}\u{b}", &["\u{1f466}",
+        "\u{b}"]), ("\u{1f466}\u{308}\u{b}", &["\u{1f466}\u{308}", "\u{b}"]), ("\u{1f466}\u{3031}",
+        &["\u{1f466}", "\u{3031}"]), ("\u{1f466}\u{308}\u{3031}", &["\u{1f466}\u{308}",
+        "\u{3031}"]), ("\u{1f466}\u{41}", &["\u{1f466}", "\u{41}"]), ("\u{1f466}\u{308}\u{41}",
+        &["\u{1f466}\u{308}", "\u{41}"]), ("\u{1f466}\u{3a}", &["\u{1f466}", "\u{3a}"]),
+        ("\u{1f466}\u{308}\u{3a}", &["\u{1f466}\u{308}", "\u{3a}"]), ("\u{1f466}\u{2c}",
+        &["\u{1f466}", "\u{2c}"]), ("\u{1f466}\u{308}\u{2c}", &["\u{1f466}\u{308}", "\u{2c}"]),
+        ("\u{1f466}\u{2e}", &["\u{1f466}", "\u{2e}"]), ("\u{1f466}\u{308}\u{2e}",
+        &["\u{1f466}\u{308}", "\u{2e}"]), ("\u{1f466}\u{30}", &["\u{1f466}", "\u{30}"]),
+        ("\u{1f466}\u{308}\u{30}", &["\u{1f466}\u{308}", "\u{30}"]), ("\u{1f466}\u{5f}",
+        &["\u{1f466}", "\u{5f}"]), ("\u{1f466}\u{308}\u{5f}", &["\u{1f466}\u{308}", "\u{5f}"]),
+        ("\u{1f466}\u{1f1e6}", &["\u{1f466}", "\u{1f1e6}"]), ("\u{1f466}\u{308}\u{1f1e6}",
+        &["\u{1f466}\u{308}", "\u{1f1e6}"]), ("\u{1f466}\u{5d0}", &["\u{1f466}", "\u{5d0}"]),
+        ("\u{1f466}\u{308}\u{5d0}", &["\u{1f466}\u{308}", "\u{5d0}"]), ("\u{1f466}\u{22}",
+        &["\u{1f466}", "\u{22}"]), ("\u{1f466}\u{308}\u{22}", &["\u{1f466}\u{308}", "\u{22}"]),
+        ("\u{1f466}\u{27}", &["\u{1f466}", "\u{27}"]), ("\u{1f466}\u{308}\u{27}",
+        &["\u{1f466}\u{308}", "\u{27}"]), ("\u{1f466}\u{261d}", &["\u{1f466}", "\u{261d}"]),
+        ("\u{1f466}\u{308}\u{261d}", &["\u{1f466}\u{308}", "\u{261d}"]), ("\u{1f466}\u{1f3fb}",
+        &["\u{1f466}\u{1f3fb}"]), ("\u{1f466}\u{308}\u{1f3fb}", &["\u{1f466}\u{308}\u{1f3fb}"]),
+        ("\u{1f466}\u{2764}", &["\u{1f466}", "\u{2764}"]), ("\u{1f466}\u{308}\u{2764}",
+        &["\u{1f466}\u{308}", "\u{2764}"]), ("\u{1f466}\u{1f466}", &["\u{1f466}", "\u{1f466}"]),
+        ("\u{1f466}\u{308}\u{1f466}", &["\u{1f466}\u{308}", "\u{1f466}"]), ("\u{1f466}\u{ad}",
+        &["\u{1f466}\u{ad}"]), ("\u{1f466}\u{308}\u{ad}", &["\u{1f466}\u{308}\u{ad}"]),
+        ("\u{1f466}\u{300}", &["\u{1f466}\u{300}"]), ("\u{1f466}\u{308}\u{300}",
+        &["\u{1f466}\u{308}\u{300}"]), ("\u{1f466}\u{200d}", &["\u{1f466}\u{200d}"]),
+        ("\u{1f466}\u{308}\u{200d}", &["\u{1f466}\u{308}\u{200d}"]), ("\u{1f466}\u{61}\u{2060}",
+        &["\u{1f466}", "\u{61}\u{2060}"]), ("\u{1f466}\u{308}\u{61}\u{2060}", &["\u{1f466}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{1f466}\u{61}\u{3a}", &["\u{1f466}", "\u{61}", "\u{3a}"]),
+        ("\u{1f466}\u{308}\u{61}\u{3a}", &["\u{1f466}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{1f466}\u{61}\u{27}", &["\u{1f466}", "\u{61}", "\u{27}"]),
+        ("\u{1f466}\u{308}\u{61}\u{27}", &["\u{1f466}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{1f466}\u{61}\u{27}\u{2060}", &["\u{1f466}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1f466}\u{308}\u{61}\u{27}\u{2060}", &["\u{1f466}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{1f466}\u{61}\u{2c}", &["\u{1f466}", "\u{61}", "\u{2c}"]),
+        ("\u{1f466}\u{308}\u{61}\u{2c}", &["\u{1f466}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{1f466}\u{31}\u{3a}", &["\u{1f466}", "\u{31}", "\u{3a}"]),
+        ("\u{1f466}\u{308}\u{31}\u{3a}", &["\u{1f466}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{1f466}\u{31}\u{27}", &["\u{1f466}", "\u{31}", "\u{27}"]),
+        ("\u{1f466}\u{308}\u{31}\u{27}", &["\u{1f466}\u{308}", "\u{31}", "\u{27}"]),
+        ("\u{1f466}\u{31}\u{2c}", &["\u{1f466}", "\u{31}", "\u{2c}"]),
+        ("\u{1f466}\u{308}\u{31}\u{2c}", &["\u{1f466}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{1f466}\u{31}\u{2e}\u{2060}", &["\u{1f466}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{1f466}\u{308}\u{31}\u{2e}\u{2060}", &["\u{1f466}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{ad}\u{1}", &["\u{ad}", "\u{1}"]), ("\u{ad}\u{308}\u{1}", &["\u{ad}\u{308}", "\u{1}"]),
+        ("\u{ad}\u{d}", &["\u{ad}", "\u{d}"]), ("\u{ad}\u{308}\u{d}", &["\u{ad}\u{308}", "\u{d}"]),
+        ("\u{ad}\u{a}", &["\u{ad}", "\u{a}"]), ("\u{ad}\u{308}\u{a}", &["\u{ad}\u{308}", "\u{a}"]),
+        ("\u{ad}\u{b}", &["\u{ad}", "\u{b}"]), ("\u{ad}\u{308}\u{b}", &["\u{ad}\u{308}", "\u{b}"]),
+        ("\u{ad}\u{3031}", &["\u{ad}", "\u{3031}"]), ("\u{ad}\u{308}\u{3031}", &["\u{ad}\u{308}",
+        "\u{3031}"]), ("\u{ad}\u{41}", &["\u{ad}", "\u{41}"]), ("\u{ad}\u{308}\u{41}",
+        &["\u{ad}\u{308}", "\u{41}"]), ("\u{ad}\u{3a}", &["\u{ad}", "\u{3a}"]),
+        ("\u{ad}\u{308}\u{3a}", &["\u{ad}\u{308}", "\u{3a}"]), ("\u{ad}\u{2c}", &["\u{ad}",
+        "\u{2c}"]), ("\u{ad}\u{308}\u{2c}", &["\u{ad}\u{308}", "\u{2c}"]), ("\u{ad}\u{2e}",
+        &["\u{ad}", "\u{2e}"]), ("\u{ad}\u{308}\u{2e}", &["\u{ad}\u{308}", "\u{2e}"]),
+        ("\u{ad}\u{30}", &["\u{ad}", "\u{30}"]), ("\u{ad}\u{308}\u{30}", &["\u{ad}\u{308}",
+        "\u{30}"]), ("\u{ad}\u{5f}", &["\u{ad}", "\u{5f}"]), ("\u{ad}\u{308}\u{5f}",
+        &["\u{ad}\u{308}", "\u{5f}"]), ("\u{ad}\u{1f1e6}", &["\u{ad}", "\u{1f1e6}"]),
+        ("\u{ad}\u{308}\u{1f1e6}", &["\u{ad}\u{308}", "\u{1f1e6}"]), ("\u{ad}\u{5d0}", &["\u{ad}",
+        "\u{5d0}"]), ("\u{ad}\u{308}\u{5d0}", &["\u{ad}\u{308}", "\u{5d0}"]), ("\u{ad}\u{22}",
+        &["\u{ad}", "\u{22}"]), ("\u{ad}\u{308}\u{22}", &["\u{ad}\u{308}", "\u{22}"]),
+        ("\u{ad}\u{27}", &["\u{ad}", "\u{27}"]), ("\u{ad}\u{308}\u{27}", &["\u{ad}\u{308}",
+        "\u{27}"]), ("\u{ad}\u{261d}", &["\u{ad}", "\u{261d}"]), ("\u{ad}\u{308}\u{261d}",
+        &["\u{ad}\u{308}", "\u{261d}"]), ("\u{ad}\u{1f3fb}", &["\u{ad}", "\u{1f3fb}"]),
+        ("\u{ad}\u{308}\u{1f3fb}", &["\u{ad}\u{308}", "\u{1f3fb}"]), ("\u{ad}\u{2764}", &["\u{ad}",
+        "\u{2764}"]), ("\u{ad}\u{308}\u{2764}", &["\u{ad}\u{308}", "\u{2764}"]), ("\u{ad}\u{1f466}",
+        &["\u{ad}", "\u{1f466}"]), ("\u{ad}\u{308}\u{1f466}", &["\u{ad}\u{308}", "\u{1f466}"]),
+        ("\u{ad}\u{ad}", &["\u{ad}\u{ad}"]), ("\u{ad}\u{308}\u{ad}", &["\u{ad}\u{308}\u{ad}"]),
+        ("\u{ad}\u{300}", &["\u{ad}\u{300}"]), ("\u{ad}\u{308}\u{300}", &["\u{ad}\u{308}\u{300}"]),
+        ("\u{ad}\u{200d}", &["\u{ad}\u{200d}"]), ("\u{ad}\u{308}\u{200d}",
+        &["\u{ad}\u{308}\u{200d}"]), ("\u{ad}\u{61}\u{2060}", &["\u{ad}", "\u{61}\u{2060}"]),
+        ("\u{ad}\u{308}\u{61}\u{2060}", &["\u{ad}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{ad}\u{61}\u{3a}", &["\u{ad}", "\u{61}", "\u{3a}"]), ("\u{ad}\u{308}\u{61}\u{3a}",
+        &["\u{ad}\u{308}", "\u{61}", "\u{3a}"]), ("\u{ad}\u{61}\u{27}", &["\u{ad}", "\u{61}",
+        "\u{27}"]), ("\u{ad}\u{308}\u{61}\u{27}", &["\u{ad}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{ad}\u{61}\u{27}\u{2060}", &["\u{ad}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{ad}\u{308}\u{61}\u{27}\u{2060}", &["\u{ad}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{ad}\u{61}\u{2c}", &["\u{ad}", "\u{61}", "\u{2c}"]), ("\u{ad}\u{308}\u{61}\u{2c}",
+        &["\u{ad}\u{308}", "\u{61}", "\u{2c}"]), ("\u{ad}\u{31}\u{3a}", &["\u{ad}", "\u{31}",
+        "\u{3a}"]), ("\u{ad}\u{308}\u{31}\u{3a}", &["\u{ad}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{ad}\u{31}\u{27}", &["\u{ad}", "\u{31}", "\u{27}"]), ("\u{ad}\u{308}\u{31}\u{27}",
+        &["\u{ad}\u{308}", "\u{31}", "\u{27}"]), ("\u{ad}\u{31}\u{2c}", &["\u{ad}", "\u{31}",
+        "\u{2c}"]), ("\u{ad}\u{308}\u{31}\u{2c}", &["\u{ad}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{ad}\u{31}\u{2e}\u{2060}", &["\u{ad}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{ad}\u{308}\u{31}\u{2e}\u{2060}", &["\u{ad}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{300}\u{1}", &["\u{300}", "\u{1}"]), ("\u{300}\u{308}\u{1}", &["\u{300}\u{308}",
+        "\u{1}"]), ("\u{300}\u{d}", &["\u{300}", "\u{d}"]), ("\u{300}\u{308}\u{d}",
+        &["\u{300}\u{308}", "\u{d}"]), ("\u{300}\u{a}", &["\u{300}", "\u{a}"]),
+        ("\u{300}\u{308}\u{a}", &["\u{300}\u{308}", "\u{a}"]), ("\u{300}\u{b}", &["\u{300}",
+        "\u{b}"]), ("\u{300}\u{308}\u{b}", &["\u{300}\u{308}", "\u{b}"]), ("\u{300}\u{3031}",
+        &["\u{300}", "\u{3031}"]), ("\u{300}\u{308}\u{3031}", &["\u{300}\u{308}", "\u{3031}"]),
+        ("\u{300}\u{41}", &["\u{300}", "\u{41}"]), ("\u{300}\u{308}\u{41}", &["\u{300}\u{308}",
+        "\u{41}"]), ("\u{300}\u{3a}", &["\u{300}", "\u{3a}"]), ("\u{300}\u{308}\u{3a}",
+        &["\u{300}\u{308}", "\u{3a}"]), ("\u{300}\u{2c}", &["\u{300}", "\u{2c}"]),
+        ("\u{300}\u{308}\u{2c}", &["\u{300}\u{308}", "\u{2c}"]), ("\u{300}\u{2e}", &["\u{300}",
+        "\u{2e}"]), ("\u{300}\u{308}\u{2e}", &["\u{300}\u{308}", "\u{2e}"]), ("\u{300}\u{30}",
+        &["\u{300}", "\u{30}"]), ("\u{300}\u{308}\u{30}", &["\u{300}\u{308}", "\u{30}"]),
+        ("\u{300}\u{5f}", &["\u{300}", "\u{5f}"]), ("\u{300}\u{308}\u{5f}", &["\u{300}\u{308}",
+        "\u{5f}"]), ("\u{300}\u{1f1e6}", &["\u{300}", "\u{1f1e6}"]), ("\u{300}\u{308}\u{1f1e6}",
+        &["\u{300}\u{308}", "\u{1f1e6}"]), ("\u{300}\u{5d0}", &["\u{300}", "\u{5d0}"]),
+        ("\u{300}\u{308}\u{5d0}", &["\u{300}\u{308}", "\u{5d0}"]), ("\u{300}\u{22}", &["\u{300}",
+        "\u{22}"]), ("\u{300}\u{308}\u{22}", &["\u{300}\u{308}", "\u{22}"]), ("\u{300}\u{27}",
+        &["\u{300}", "\u{27}"]), ("\u{300}\u{308}\u{27}", &["\u{300}\u{308}", "\u{27}"]),
+        ("\u{300}\u{261d}", &["\u{300}", "\u{261d}"]), ("\u{300}\u{308}\u{261d}",
+        &["\u{300}\u{308}", "\u{261d}"]), ("\u{300}\u{1f3fb}", &["\u{300}", "\u{1f3fb}"]),
+        ("\u{300}\u{308}\u{1f3fb}", &["\u{300}\u{308}", "\u{1f3fb}"]), ("\u{300}\u{2764}",
+        &["\u{300}", "\u{2764}"]), ("\u{300}\u{308}\u{2764}", &["\u{300}\u{308}", "\u{2764}"]),
+        ("\u{300}\u{1f466}", &["\u{300}", "\u{1f466}"]), ("\u{300}\u{308}\u{1f466}",
+        &["\u{300}\u{308}", "\u{1f466}"]), ("\u{300}\u{ad}", &["\u{300}\u{ad}"]),
+        ("\u{300}\u{308}\u{ad}", &["\u{300}\u{308}\u{ad}"]), ("\u{300}\u{300}",
+        &["\u{300}\u{300}"]), ("\u{300}\u{308}\u{300}", &["\u{300}\u{308}\u{300}"]),
+        ("\u{300}\u{200d}", &["\u{300}\u{200d}"]), ("\u{300}\u{308}\u{200d}",
+        &["\u{300}\u{308}\u{200d}"]), ("\u{300}\u{61}\u{2060}", &["\u{300}", "\u{61}\u{2060}"]),
+        ("\u{300}\u{308}\u{61}\u{2060}", &["\u{300}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{300}\u{61}\u{3a}", &["\u{300}", "\u{61}", "\u{3a}"]), ("\u{300}\u{308}\u{61}\u{3a}",
+        &["\u{300}\u{308}", "\u{61}", "\u{3a}"]), ("\u{300}\u{61}\u{27}", &["\u{300}", "\u{61}",
+        "\u{27}"]), ("\u{300}\u{308}\u{61}\u{27}", &["\u{300}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{300}\u{61}\u{27}\u{2060}", &["\u{300}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{300}\u{308}\u{61}\u{27}\u{2060}", &["\u{300}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{300}\u{61}\u{2c}", &["\u{300}", "\u{61}", "\u{2c}"]), ("\u{300}\u{308}\u{61}\u{2c}",
+        &["\u{300}\u{308}", "\u{61}", "\u{2c}"]), ("\u{300}\u{31}\u{3a}", &["\u{300}", "\u{31}",
+        "\u{3a}"]), ("\u{300}\u{308}\u{31}\u{3a}", &["\u{300}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{300}\u{31}\u{27}", &["\u{300}", "\u{31}", "\u{27}"]), ("\u{300}\u{308}\u{31}\u{27}",
+        &["\u{300}\u{308}", "\u{31}", "\u{27}"]), ("\u{300}\u{31}\u{2c}", &["\u{300}", "\u{31}",
+        "\u{2c}"]), ("\u{300}\u{308}\u{31}\u{2c}", &["\u{300}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{300}\u{31}\u{2e}\u{2060}", &["\u{300}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{300}\u{308}\u{31}\u{2e}\u{2060}", &["\u{300}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{200d}\u{1}", &["\u{200d}", "\u{1}"]), ("\u{200d}\u{308}\u{1}", &["\u{200d}\u{308}",
+        "\u{1}"]), ("\u{200d}\u{d}", &["\u{200d}", "\u{d}"]), ("\u{200d}\u{308}\u{d}",
+        &["\u{200d}\u{308}", "\u{d}"]), ("\u{200d}\u{a}", &["\u{200d}", "\u{a}"]),
+        ("\u{200d}\u{308}\u{a}", &["\u{200d}\u{308}", "\u{a}"]), ("\u{200d}\u{b}", &["\u{200d}",
+        "\u{b}"]), ("\u{200d}\u{308}\u{b}", &["\u{200d}\u{308}", "\u{b}"]), ("\u{200d}\u{3031}",
+        &["\u{200d}", "\u{3031}"]), ("\u{200d}\u{308}\u{3031}", &["\u{200d}\u{308}", "\u{3031}"]),
+        ("\u{200d}\u{41}", &["\u{200d}", "\u{41}"]), ("\u{200d}\u{308}\u{41}", &["\u{200d}\u{308}",
+        "\u{41}"]), ("\u{200d}\u{3a}", &["\u{200d}", "\u{3a}"]), ("\u{200d}\u{308}\u{3a}",
+        &["\u{200d}\u{308}", "\u{3a}"]), ("\u{200d}\u{2c}", &["\u{200d}", "\u{2c}"]),
+        ("\u{200d}\u{308}\u{2c}", &["\u{200d}\u{308}", "\u{2c}"]), ("\u{200d}\u{2e}", &["\u{200d}",
+        "\u{2e}"]), ("\u{200d}\u{308}\u{2e}", &["\u{200d}\u{308}", "\u{2e}"]), ("\u{200d}\u{30}",
+        &["\u{200d}", "\u{30}"]), ("\u{200d}\u{308}\u{30}", &["\u{200d}\u{308}", "\u{30}"]),
+        ("\u{200d}\u{5f}", &["\u{200d}", "\u{5f}"]), ("\u{200d}\u{308}\u{5f}", &["\u{200d}\u{308}",
+        "\u{5f}"]), ("\u{200d}\u{1f1e6}", &["\u{200d}", "\u{1f1e6}"]), ("\u{200d}\u{308}\u{1f1e6}",
+        &["\u{200d}\u{308}", "\u{1f1e6}"]), ("\u{200d}\u{5d0}", &["\u{200d}", "\u{5d0}"]),
+        ("\u{200d}\u{308}\u{5d0}", &["\u{200d}\u{308}", "\u{5d0}"]), ("\u{200d}\u{22}",
+        &["\u{200d}", "\u{22}"]), ("\u{200d}\u{308}\u{22}", &["\u{200d}\u{308}", "\u{22}"]),
+        ("\u{200d}\u{27}", &["\u{200d}", "\u{27}"]), ("\u{200d}\u{308}\u{27}", &["\u{200d}\u{308}",
+        "\u{27}"]), ("\u{200d}\u{261d}", &["\u{200d}", "\u{261d}"]), ("\u{200d}\u{308}\u{261d}",
+        &["\u{200d}\u{308}", "\u{261d}"]), ("\u{200d}\u{1f3fb}", &["\u{200d}", "\u{1f3fb}"]),
+        ("\u{200d}\u{308}\u{1f3fb}", &["\u{200d}\u{308}", "\u{1f3fb}"]), ("\u{200d}\u{2764}",
+        &["\u{200d}\u{2764}"]), ("\u{200d}\u{308}\u{2764}", &["\u{200d}\u{308}", "\u{2764}"]),
+        ("\u{200d}\u{1f466}", &["\u{200d}\u{1f466}"]), ("\u{200d}\u{308}\u{1f466}",
+        &["\u{200d}\u{308}", "\u{1f466}"]), ("\u{200d}\u{ad}", &["\u{200d}\u{ad}"]),
+        ("\u{200d}\u{308}\u{ad}", &["\u{200d}\u{308}\u{ad}"]), ("\u{200d}\u{300}",
+        &["\u{200d}\u{300}"]), ("\u{200d}\u{308}\u{300}", &["\u{200d}\u{308}\u{300}"]),
+        ("\u{200d}\u{200d}", &["\u{200d}\u{200d}"]), ("\u{200d}\u{308}\u{200d}",
+        &["\u{200d}\u{308}\u{200d}"]), ("\u{200d}\u{61}\u{2060}", &["\u{200d}", "\u{61}\u{2060}"]),
+        ("\u{200d}\u{308}\u{61}\u{2060}", &["\u{200d}\u{308}", "\u{61}\u{2060}"]),
+        ("\u{200d}\u{61}\u{3a}", &["\u{200d}", "\u{61}", "\u{3a}"]), ("\u{200d}\u{308}\u{61}\u{3a}",
+        &["\u{200d}\u{308}", "\u{61}", "\u{3a}"]), ("\u{200d}\u{61}\u{27}", &["\u{200d}", "\u{61}",
+        "\u{27}"]), ("\u{200d}\u{308}\u{61}\u{27}", &["\u{200d}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{200d}\u{61}\u{27}\u{2060}", &["\u{200d}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{200d}\u{308}\u{61}\u{27}\u{2060}", &["\u{200d}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{200d}\u{61}\u{2c}", &["\u{200d}", "\u{61}", "\u{2c}"]), ("\u{200d}\u{308}\u{61}\u{2c}",
+        &["\u{200d}\u{308}", "\u{61}", "\u{2c}"]), ("\u{200d}\u{31}\u{3a}", &["\u{200d}", "\u{31}",
+        "\u{3a}"]), ("\u{200d}\u{308}\u{31}\u{3a}", &["\u{200d}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{200d}\u{31}\u{27}", &["\u{200d}", "\u{31}", "\u{27}"]), ("\u{200d}\u{308}\u{31}\u{27}",
+        &["\u{200d}\u{308}", "\u{31}", "\u{27}"]), ("\u{200d}\u{31}\u{2c}", &["\u{200d}", "\u{31}",
+        "\u{2c}"]), ("\u{200d}\u{308}\u{31}\u{2c}", &["\u{200d}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{200d}\u{31}\u{2e}\u{2060}", &["\u{200d}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{200d}\u{308}\u{31}\u{2e}\u{2060}", &["\u{200d}\u{308}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{61}\u{2060}\u{1}", &["\u{61}\u{2060}", "\u{1}"]), ("\u{61}\u{2060}\u{308}\u{1}",
+        &["\u{61}\u{2060}\u{308}", "\u{1}"]), ("\u{61}\u{2060}\u{d}", &["\u{61}\u{2060}", "\u{d}"]),
+        ("\u{61}\u{2060}\u{308}\u{d}", &["\u{61}\u{2060}\u{308}", "\u{d}"]), ("\u{61}\u{2060}\u{a}",
+        &["\u{61}\u{2060}", "\u{a}"]), ("\u{61}\u{2060}\u{308}\u{a}", &["\u{61}\u{2060}\u{308}",
+        "\u{a}"]), ("\u{61}\u{2060}\u{b}", &["\u{61}\u{2060}", "\u{b}"]),
+        ("\u{61}\u{2060}\u{308}\u{b}", &["\u{61}\u{2060}\u{308}", "\u{b}"]),
+        ("\u{61}\u{2060}\u{3031}", &["\u{61}\u{2060}", "\u{3031}"]),
+        ("\u{61}\u{2060}\u{308}\u{3031}", &["\u{61}\u{2060}\u{308}", "\u{3031}"]),
+        ("\u{61}\u{2060}\u{41}", &["\u{61}\u{2060}\u{41}"]), ("\u{61}\u{2060}\u{308}\u{41}",
+        &["\u{61}\u{2060}\u{308}\u{41}"]), ("\u{61}\u{2060}\u{3a}", &["\u{61}\u{2060}", "\u{3a}"]),
+        ("\u{61}\u{2060}\u{308}\u{3a}", &["\u{61}\u{2060}\u{308}", "\u{3a}"]),
+        ("\u{61}\u{2060}\u{2c}", &["\u{61}\u{2060}", "\u{2c}"]), ("\u{61}\u{2060}\u{308}\u{2c}",
+        &["\u{61}\u{2060}\u{308}", "\u{2c}"]), ("\u{61}\u{2060}\u{2e}", &["\u{61}\u{2060}",
+        "\u{2e}"]), ("\u{61}\u{2060}\u{308}\u{2e}", &["\u{61}\u{2060}\u{308}", "\u{2e}"]),
+        ("\u{61}\u{2060}\u{30}", &["\u{61}\u{2060}\u{30}"]), ("\u{61}\u{2060}\u{308}\u{30}",
+        &["\u{61}\u{2060}\u{308}\u{30}"]), ("\u{61}\u{2060}\u{5f}", &["\u{61}\u{2060}\u{5f}"]),
+        ("\u{61}\u{2060}\u{308}\u{5f}", &["\u{61}\u{2060}\u{308}\u{5f}"]),
+        ("\u{61}\u{2060}\u{1f1e6}", &["\u{61}\u{2060}", "\u{1f1e6}"]),
+        ("\u{61}\u{2060}\u{308}\u{1f1e6}", &["\u{61}\u{2060}\u{308}", "\u{1f1e6}"]),
+        ("\u{61}\u{2060}\u{5d0}", &["\u{61}\u{2060}\u{5d0}"]), ("\u{61}\u{2060}\u{308}\u{5d0}",
+        &["\u{61}\u{2060}\u{308}\u{5d0}"]), ("\u{61}\u{2060}\u{22}", &["\u{61}\u{2060}", "\u{22}"]),
+        ("\u{61}\u{2060}\u{308}\u{22}", &["\u{61}\u{2060}\u{308}", "\u{22}"]),
+        ("\u{61}\u{2060}\u{27}", &["\u{61}\u{2060}", "\u{27}"]), ("\u{61}\u{2060}\u{308}\u{27}",
+        &["\u{61}\u{2060}\u{308}", "\u{27}"]), ("\u{61}\u{2060}\u{261d}", &["\u{61}\u{2060}",
+        "\u{261d}"]), ("\u{61}\u{2060}\u{308}\u{261d}", &["\u{61}\u{2060}\u{308}", "\u{261d}"]),
+        ("\u{61}\u{2060}\u{1f3fb}", &["\u{61}\u{2060}", "\u{1f3fb}"]),
+        ("\u{61}\u{2060}\u{308}\u{1f3fb}", &["\u{61}\u{2060}\u{308}", "\u{1f3fb}"]),
+        ("\u{61}\u{2060}\u{2764}", &["\u{61}\u{2060}", "\u{2764}"]),
+        ("\u{61}\u{2060}\u{308}\u{2764}", &["\u{61}\u{2060}\u{308}", "\u{2764}"]),
+        ("\u{61}\u{2060}\u{1f466}", &["\u{61}\u{2060}", "\u{1f466}"]),
+        ("\u{61}\u{2060}\u{308}\u{1f466}", &["\u{61}\u{2060}\u{308}", "\u{1f466}"]),
+        ("\u{61}\u{2060}\u{ad}", &["\u{61}\u{2060}\u{ad}"]), ("\u{61}\u{2060}\u{308}\u{ad}",
+        &["\u{61}\u{2060}\u{308}\u{ad}"]), ("\u{61}\u{2060}\u{300}", &["\u{61}\u{2060}\u{300}"]),
+        ("\u{61}\u{2060}\u{308}\u{300}", &["\u{61}\u{2060}\u{308}\u{300}"]),
+        ("\u{61}\u{2060}\u{200d}", &["\u{61}\u{2060}\u{200d}"]), ("\u{61}\u{2060}\u{308}\u{200d}",
+        &["\u{61}\u{2060}\u{308}\u{200d}"]), ("\u{61}\u{2060}\u{61}\u{2060}",
+        &["\u{61}\u{2060}\u{61}\u{2060}"]), ("\u{61}\u{2060}\u{308}\u{61}\u{2060}",
+        &["\u{61}\u{2060}\u{308}\u{61}\u{2060}"]), ("\u{61}\u{2060}\u{61}\u{3a}",
+        &["\u{61}\u{2060}\u{61}", "\u{3a}"]), ("\u{61}\u{2060}\u{308}\u{61}\u{3a}",
+        &["\u{61}\u{2060}\u{308}\u{61}", "\u{3a}"]), ("\u{61}\u{2060}\u{61}\u{27}",
+        &["\u{61}\u{2060}\u{61}", "\u{27}"]), ("\u{61}\u{2060}\u{308}\u{61}\u{27}",
+        &["\u{61}\u{2060}\u{308}\u{61}", "\u{27}"]), ("\u{61}\u{2060}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{2060}\u{61}", "\u{27}\u{2060}"]), ("\u{61}\u{2060}\u{308}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{2060}\u{308}\u{61}", "\u{27}\u{2060}"]), ("\u{61}\u{2060}\u{61}\u{2c}",
+        &["\u{61}\u{2060}\u{61}", "\u{2c}"]), ("\u{61}\u{2060}\u{308}\u{61}\u{2c}",
+        &["\u{61}\u{2060}\u{308}\u{61}", "\u{2c}"]), ("\u{61}\u{2060}\u{31}\u{3a}",
+        &["\u{61}\u{2060}\u{31}", "\u{3a}"]), ("\u{61}\u{2060}\u{308}\u{31}\u{3a}",
+        &["\u{61}\u{2060}\u{308}\u{31}", "\u{3a}"]), ("\u{61}\u{2060}\u{31}\u{27}",
+        &["\u{61}\u{2060}\u{31}", "\u{27}"]), ("\u{61}\u{2060}\u{308}\u{31}\u{27}",
+        &["\u{61}\u{2060}\u{308}\u{31}", "\u{27}"]), ("\u{61}\u{2060}\u{31}\u{2c}",
+        &["\u{61}\u{2060}\u{31}", "\u{2c}"]), ("\u{61}\u{2060}\u{308}\u{31}\u{2c}",
+        &["\u{61}\u{2060}\u{308}\u{31}", "\u{2c}"]), ("\u{61}\u{2060}\u{31}\u{2e}\u{2060}",
+        &["\u{61}\u{2060}\u{31}", "\u{2e}\u{2060}"]), ("\u{61}\u{2060}\u{308}\u{31}\u{2e}\u{2060}",
+        &["\u{61}\u{2060}\u{308}\u{31}", "\u{2e}\u{2060}"]), ("\u{61}\u{3a}\u{1}", &["\u{61}",
+        "\u{3a}", "\u{1}"]), ("\u{61}\u{3a}\u{308}\u{1}", &["\u{61}", "\u{3a}\u{308}", "\u{1}"]),
+        ("\u{61}\u{3a}\u{d}", &["\u{61}", "\u{3a}", "\u{d}"]), ("\u{61}\u{3a}\u{308}\u{d}",
+        &["\u{61}", "\u{3a}\u{308}", "\u{d}"]), ("\u{61}\u{3a}\u{a}", &["\u{61}", "\u{3a}",
+        "\u{a}"]), ("\u{61}\u{3a}\u{308}\u{a}", &["\u{61}", "\u{3a}\u{308}", "\u{a}"]),
+        ("\u{61}\u{3a}\u{b}", &["\u{61}", "\u{3a}", "\u{b}"]), ("\u{61}\u{3a}\u{308}\u{b}",
+        &["\u{61}", "\u{3a}\u{308}", "\u{b}"]), ("\u{61}\u{3a}\u{3031}", &["\u{61}", "\u{3a}",
+        "\u{3031}"]), ("\u{61}\u{3a}\u{308}\u{3031}", &["\u{61}", "\u{3a}\u{308}", "\u{3031}"]),
+        ("\u{61}\u{3a}\u{41}", &["\u{61}\u{3a}\u{41}"]), ("\u{61}\u{3a}\u{308}\u{41}",
+        &["\u{61}\u{3a}\u{308}\u{41}"]), ("\u{61}\u{3a}\u{3a}", &["\u{61}", "\u{3a}", "\u{3a}"]),
+        ("\u{61}\u{3a}\u{308}\u{3a}", &["\u{61}", "\u{3a}\u{308}", "\u{3a}"]),
+        ("\u{61}\u{3a}\u{2c}", &["\u{61}", "\u{3a}", "\u{2c}"]), ("\u{61}\u{3a}\u{308}\u{2c}",
+        &["\u{61}", "\u{3a}\u{308}", "\u{2c}"]), ("\u{61}\u{3a}\u{2e}", &["\u{61}", "\u{3a}",
+        "\u{2e}"]), ("\u{61}\u{3a}\u{308}\u{2e}", &["\u{61}", "\u{3a}\u{308}", "\u{2e}"]),
+        ("\u{61}\u{3a}\u{30}", &["\u{61}", "\u{3a}", "\u{30}"]), ("\u{61}\u{3a}\u{308}\u{30}",
+        &["\u{61}", "\u{3a}\u{308}", "\u{30}"]), ("\u{61}\u{3a}\u{5f}", &["\u{61}", "\u{3a}",
+        "\u{5f}"]), ("\u{61}\u{3a}\u{308}\u{5f}", &["\u{61}", "\u{3a}\u{308}", "\u{5f}"]),
+        ("\u{61}\u{3a}\u{1f1e6}", &["\u{61}", "\u{3a}", "\u{1f1e6}"]),
+        ("\u{61}\u{3a}\u{308}\u{1f1e6}", &["\u{61}", "\u{3a}\u{308}", "\u{1f1e6}"]),
+        ("\u{61}\u{3a}\u{5d0}", &["\u{61}\u{3a}\u{5d0}"]), ("\u{61}\u{3a}\u{308}\u{5d0}",
+        &["\u{61}\u{3a}\u{308}\u{5d0}"]), ("\u{61}\u{3a}\u{22}", &["\u{61}", "\u{3a}", "\u{22}"]),
+        ("\u{61}\u{3a}\u{308}\u{22}", &["\u{61}", "\u{3a}\u{308}", "\u{22}"]),
+        ("\u{61}\u{3a}\u{27}", &["\u{61}", "\u{3a}", "\u{27}"]), ("\u{61}\u{3a}\u{308}\u{27}",
+        &["\u{61}", "\u{3a}\u{308}", "\u{27}"]), ("\u{61}\u{3a}\u{261d}", &["\u{61}", "\u{3a}",
+        "\u{261d}"]), ("\u{61}\u{3a}\u{308}\u{261d}", &["\u{61}", "\u{3a}\u{308}", "\u{261d}"]),
+        ("\u{61}\u{3a}\u{1f3fb}", &["\u{61}", "\u{3a}", "\u{1f3fb}"]),
+        ("\u{61}\u{3a}\u{308}\u{1f3fb}", &["\u{61}", "\u{3a}\u{308}", "\u{1f3fb}"]),
+        ("\u{61}\u{3a}\u{2764}", &["\u{61}", "\u{3a}", "\u{2764}"]), ("\u{61}\u{3a}\u{308}\u{2764}",
+        &["\u{61}", "\u{3a}\u{308}", "\u{2764}"]), ("\u{61}\u{3a}\u{1f466}", &["\u{61}", "\u{3a}",
+        "\u{1f466}"]), ("\u{61}\u{3a}\u{308}\u{1f466}", &["\u{61}", "\u{3a}\u{308}", "\u{1f466}"]),
+        ("\u{61}\u{3a}\u{ad}", &["\u{61}", "\u{3a}\u{ad}"]), ("\u{61}\u{3a}\u{308}\u{ad}",
+        &["\u{61}", "\u{3a}\u{308}\u{ad}"]), ("\u{61}\u{3a}\u{300}", &["\u{61}", "\u{3a}\u{300}"]),
+        ("\u{61}\u{3a}\u{308}\u{300}", &["\u{61}", "\u{3a}\u{308}\u{300}"]),
+        ("\u{61}\u{3a}\u{200d}", &["\u{61}", "\u{3a}\u{200d}"]), ("\u{61}\u{3a}\u{308}\u{200d}",
+        &["\u{61}", "\u{3a}\u{308}\u{200d}"]), ("\u{61}\u{3a}\u{61}\u{2060}",
+        &["\u{61}\u{3a}\u{61}\u{2060}"]), ("\u{61}\u{3a}\u{308}\u{61}\u{2060}",
+        &["\u{61}\u{3a}\u{308}\u{61}\u{2060}"]), ("\u{61}\u{3a}\u{61}\u{3a}",
+        &["\u{61}\u{3a}\u{61}", "\u{3a}"]), ("\u{61}\u{3a}\u{308}\u{61}\u{3a}",
+        &["\u{61}\u{3a}\u{308}\u{61}", "\u{3a}"]), ("\u{61}\u{3a}\u{61}\u{27}",
+        &["\u{61}\u{3a}\u{61}", "\u{27}"]), ("\u{61}\u{3a}\u{308}\u{61}\u{27}",
+        &["\u{61}\u{3a}\u{308}\u{61}", "\u{27}"]), ("\u{61}\u{3a}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{3a}\u{61}", "\u{27}\u{2060}"]), ("\u{61}\u{3a}\u{308}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{3a}\u{308}\u{61}", "\u{27}\u{2060}"]), ("\u{61}\u{3a}\u{61}\u{2c}",
+        &["\u{61}\u{3a}\u{61}", "\u{2c}"]), ("\u{61}\u{3a}\u{308}\u{61}\u{2c}",
+        &["\u{61}\u{3a}\u{308}\u{61}", "\u{2c}"]), ("\u{61}\u{3a}\u{31}\u{3a}", &["\u{61}",
+        "\u{3a}", "\u{31}", "\u{3a}"]), ("\u{61}\u{3a}\u{308}\u{31}\u{3a}", &["\u{61}",
+        "\u{3a}\u{308}", "\u{31}", "\u{3a}"]), ("\u{61}\u{3a}\u{31}\u{27}", &["\u{61}", "\u{3a}",
+        "\u{31}", "\u{27}"]), ("\u{61}\u{3a}\u{308}\u{31}\u{27}", &["\u{61}", "\u{3a}\u{308}",
+        "\u{31}", "\u{27}"]), ("\u{61}\u{3a}\u{31}\u{2c}", &["\u{61}", "\u{3a}", "\u{31}",
+        "\u{2c}"]), ("\u{61}\u{3a}\u{308}\u{31}\u{2c}", &["\u{61}", "\u{3a}\u{308}", "\u{31}",
+        "\u{2c}"]), ("\u{61}\u{3a}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{3a}", "\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{61}\u{3a}\u{308}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{3a}\u{308}",
+        "\u{31}", "\u{2e}\u{2060}"]), ("\u{61}\u{27}\u{1}", &["\u{61}", "\u{27}", "\u{1}"]),
+        ("\u{61}\u{27}\u{308}\u{1}", &["\u{61}", "\u{27}\u{308}", "\u{1}"]), ("\u{61}\u{27}\u{d}",
+        &["\u{61}", "\u{27}", "\u{d}"]), ("\u{61}\u{27}\u{308}\u{d}", &["\u{61}", "\u{27}\u{308}",
+        "\u{d}"]), ("\u{61}\u{27}\u{a}", &["\u{61}", "\u{27}", "\u{a}"]),
+        ("\u{61}\u{27}\u{308}\u{a}", &["\u{61}", "\u{27}\u{308}", "\u{a}"]), ("\u{61}\u{27}\u{b}",
+        &["\u{61}", "\u{27}", "\u{b}"]), ("\u{61}\u{27}\u{308}\u{b}", &["\u{61}", "\u{27}\u{308}",
+        "\u{b}"]), ("\u{61}\u{27}\u{3031}", &["\u{61}", "\u{27}", "\u{3031}"]),
+        ("\u{61}\u{27}\u{308}\u{3031}", &["\u{61}", "\u{27}\u{308}", "\u{3031}"]),
+        ("\u{61}\u{27}\u{41}", &["\u{61}\u{27}\u{41}"]), ("\u{61}\u{27}\u{308}\u{41}",
+        &["\u{61}\u{27}\u{308}\u{41}"]), ("\u{61}\u{27}\u{3a}", &["\u{61}", "\u{27}", "\u{3a}"]),
+        ("\u{61}\u{27}\u{308}\u{3a}", &["\u{61}", "\u{27}\u{308}", "\u{3a}"]),
+        ("\u{61}\u{27}\u{2c}", &["\u{61}", "\u{27}", "\u{2c}"]), ("\u{61}\u{27}\u{308}\u{2c}",
+        &["\u{61}", "\u{27}\u{308}", "\u{2c}"]), ("\u{61}\u{27}\u{2e}", &["\u{61}", "\u{27}",
+        "\u{2e}"]), ("\u{61}\u{27}\u{308}\u{2e}", &["\u{61}", "\u{27}\u{308}", "\u{2e}"]),
+        ("\u{61}\u{27}\u{30}", &["\u{61}", "\u{27}", "\u{30}"]), ("\u{61}\u{27}\u{308}\u{30}",
+        &["\u{61}", "\u{27}\u{308}", "\u{30}"]), ("\u{61}\u{27}\u{5f}", &["\u{61}", "\u{27}",
+        "\u{5f}"]), ("\u{61}\u{27}\u{308}\u{5f}", &["\u{61}", "\u{27}\u{308}", "\u{5f}"]),
+        ("\u{61}\u{27}\u{1f1e6}", &["\u{61}", "\u{27}", "\u{1f1e6}"]),
+        ("\u{61}\u{27}\u{308}\u{1f1e6}", &["\u{61}", "\u{27}\u{308}", "\u{1f1e6}"]),
+        ("\u{61}\u{27}\u{5d0}", &["\u{61}\u{27}\u{5d0}"]), ("\u{61}\u{27}\u{308}\u{5d0}",
+        &["\u{61}\u{27}\u{308}\u{5d0}"]), ("\u{61}\u{27}\u{22}", &["\u{61}", "\u{27}", "\u{22}"]),
+        ("\u{61}\u{27}\u{308}\u{22}", &["\u{61}", "\u{27}\u{308}", "\u{22}"]),
+        ("\u{61}\u{27}\u{27}", &["\u{61}", "\u{27}", "\u{27}"]), ("\u{61}\u{27}\u{308}\u{27}",
+        &["\u{61}", "\u{27}\u{308}", "\u{27}"]), ("\u{61}\u{27}\u{261d}", &["\u{61}", "\u{27}",
+        "\u{261d}"]), ("\u{61}\u{27}\u{308}\u{261d}", &["\u{61}", "\u{27}\u{308}", "\u{261d}"]),
+        ("\u{61}\u{27}\u{1f3fb}", &["\u{61}", "\u{27}", "\u{1f3fb}"]),
+        ("\u{61}\u{27}\u{308}\u{1f3fb}", &["\u{61}", "\u{27}\u{308}", "\u{1f3fb}"]),
+        ("\u{61}\u{27}\u{2764}", &["\u{61}", "\u{27}", "\u{2764}"]), ("\u{61}\u{27}\u{308}\u{2764}",
+        &["\u{61}", "\u{27}\u{308}", "\u{2764}"]), ("\u{61}\u{27}\u{1f466}", &["\u{61}", "\u{27}",
+        "\u{1f466}"]), ("\u{61}\u{27}\u{308}\u{1f466}", &["\u{61}", "\u{27}\u{308}", "\u{1f466}"]),
+        ("\u{61}\u{27}\u{ad}", &["\u{61}", "\u{27}\u{ad}"]), ("\u{61}\u{27}\u{308}\u{ad}",
+        &["\u{61}", "\u{27}\u{308}\u{ad}"]), ("\u{61}\u{27}\u{300}", &["\u{61}", "\u{27}\u{300}"]),
+        ("\u{61}\u{27}\u{308}\u{300}", &["\u{61}", "\u{27}\u{308}\u{300}"]),
+        ("\u{61}\u{27}\u{200d}", &["\u{61}", "\u{27}\u{200d}"]), ("\u{61}\u{27}\u{308}\u{200d}",
+        &["\u{61}", "\u{27}\u{308}\u{200d}"]), ("\u{61}\u{27}\u{61}\u{2060}",
+        &["\u{61}\u{27}\u{61}\u{2060}"]), ("\u{61}\u{27}\u{308}\u{61}\u{2060}",
+        &["\u{61}\u{27}\u{308}\u{61}\u{2060}"]), ("\u{61}\u{27}\u{61}\u{3a}",
+        &["\u{61}\u{27}\u{61}", "\u{3a}"]), ("\u{61}\u{27}\u{308}\u{61}\u{3a}",
+        &["\u{61}\u{27}\u{308}\u{61}", "\u{3a}"]), ("\u{61}\u{27}\u{61}\u{27}",
+        &["\u{61}\u{27}\u{61}", "\u{27}"]), ("\u{61}\u{27}\u{308}\u{61}\u{27}",
+        &["\u{61}\u{27}\u{308}\u{61}", "\u{27}"]), ("\u{61}\u{27}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{27}\u{61}", "\u{27}\u{2060}"]), ("\u{61}\u{27}\u{308}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{27}\u{308}\u{61}", "\u{27}\u{2060}"]), ("\u{61}\u{27}\u{61}\u{2c}",
+        &["\u{61}\u{27}\u{61}", "\u{2c}"]), ("\u{61}\u{27}\u{308}\u{61}\u{2c}",
+        &["\u{61}\u{27}\u{308}\u{61}", "\u{2c}"]), ("\u{61}\u{27}\u{31}\u{3a}", &["\u{61}",
+        "\u{27}", "\u{31}", "\u{3a}"]), ("\u{61}\u{27}\u{308}\u{31}\u{3a}", &["\u{61}",
+        "\u{27}\u{308}", "\u{31}", "\u{3a}"]), ("\u{61}\u{27}\u{31}\u{27}", &["\u{61}", "\u{27}",
+        "\u{31}", "\u{27}"]), ("\u{61}\u{27}\u{308}\u{31}\u{27}", &["\u{61}", "\u{27}\u{308}",
+        "\u{31}", "\u{27}"]), ("\u{61}\u{27}\u{31}\u{2c}", &["\u{61}", "\u{27}", "\u{31}",
+        "\u{2c}"]), ("\u{61}\u{27}\u{308}\u{31}\u{2c}", &["\u{61}", "\u{27}\u{308}", "\u{31}",
+        "\u{2c}"]), ("\u{61}\u{27}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{27}", "\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{61}\u{27}\u{308}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{27}\u{308}",
+        "\u{31}", "\u{2e}\u{2060}"]), ("\u{61}\u{27}\u{2060}\u{1}", &["\u{61}", "\u{27}\u{2060}",
+        "\u{1}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{1}", &["\u{61}", "\u{27}\u{2060}\u{308}",
+        "\u{1}"]), ("\u{61}\u{27}\u{2060}\u{d}", &["\u{61}", "\u{27}\u{2060}", "\u{d}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{d}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{d}"]),
+        ("\u{61}\u{27}\u{2060}\u{a}", &["\u{61}", "\u{27}\u{2060}", "\u{a}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{a}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{a}"]),
+        ("\u{61}\u{27}\u{2060}\u{b}", &["\u{61}", "\u{27}\u{2060}", "\u{b}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{b}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{b}"]),
+        ("\u{61}\u{27}\u{2060}\u{3031}", &["\u{61}", "\u{27}\u{2060}", "\u{3031}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{3031}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{3031}"]),
+        ("\u{61}\u{27}\u{2060}\u{41}", &["\u{61}\u{27}\u{2060}\u{41}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{41}", &["\u{61}\u{27}\u{2060}\u{308}\u{41}"]),
+        ("\u{61}\u{27}\u{2060}\u{3a}", &["\u{61}", "\u{27}\u{2060}", "\u{3a}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{3a}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{3a}"]),
+        ("\u{61}\u{27}\u{2060}\u{2c}", &["\u{61}", "\u{27}\u{2060}", "\u{2c}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{2c}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{2c}"]),
+        ("\u{61}\u{27}\u{2060}\u{2e}", &["\u{61}", "\u{27}\u{2060}", "\u{2e}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{2e}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{2e}"]),
+        ("\u{61}\u{27}\u{2060}\u{30}", &["\u{61}", "\u{27}\u{2060}", "\u{30}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{30}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{30}"]),
+        ("\u{61}\u{27}\u{2060}\u{5f}", &["\u{61}", "\u{27}\u{2060}", "\u{5f}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{5f}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{5f}"]),
+        ("\u{61}\u{27}\u{2060}\u{1f1e6}", &["\u{61}", "\u{27}\u{2060}", "\u{1f1e6}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{1f1e6}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{1f1e6}"]),
+        ("\u{61}\u{27}\u{2060}\u{5d0}", &["\u{61}\u{27}\u{2060}\u{5d0}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{5d0}", &["\u{61}\u{27}\u{2060}\u{308}\u{5d0}"]),
+        ("\u{61}\u{27}\u{2060}\u{22}", &["\u{61}", "\u{27}\u{2060}", "\u{22}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{22}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{22}"]),
+        ("\u{61}\u{27}\u{2060}\u{27}", &["\u{61}", "\u{27}\u{2060}", "\u{27}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{27}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{27}"]),
+        ("\u{61}\u{27}\u{2060}\u{261d}", &["\u{61}", "\u{27}\u{2060}", "\u{261d}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{261d}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{261d}"]),
+        ("\u{61}\u{27}\u{2060}\u{1f3fb}", &["\u{61}", "\u{27}\u{2060}", "\u{1f3fb}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{1f3fb}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{1f3fb}"]),
+        ("\u{61}\u{27}\u{2060}\u{2764}", &["\u{61}", "\u{27}\u{2060}", "\u{2764}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{2764}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{2764}"]),
+        ("\u{61}\u{27}\u{2060}\u{1f466}", &["\u{61}", "\u{27}\u{2060}", "\u{1f466}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{1f466}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{1f466}"]),
+        ("\u{61}\u{27}\u{2060}\u{ad}", &["\u{61}", "\u{27}\u{2060}\u{ad}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{ad}", &["\u{61}", "\u{27}\u{2060}\u{308}\u{ad}"]),
+        ("\u{61}\u{27}\u{2060}\u{300}", &["\u{61}", "\u{27}\u{2060}\u{300}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{300}", &["\u{61}", "\u{27}\u{2060}\u{308}\u{300}"]),
+        ("\u{61}\u{27}\u{2060}\u{200d}", &["\u{61}", "\u{27}\u{2060}\u{200d}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{200d}", &["\u{61}", "\u{27}\u{2060}\u{308}\u{200d}"]),
+        ("\u{61}\u{27}\u{2060}\u{61}\u{2060}", &["\u{61}\u{27}\u{2060}\u{61}\u{2060}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{61}\u{2060}",
+        &["\u{61}\u{27}\u{2060}\u{308}\u{61}\u{2060}"]), ("\u{61}\u{27}\u{2060}\u{61}\u{3a}",
+        &["\u{61}\u{27}\u{2060}\u{61}", "\u{3a}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{61}\u{3a}",
+        &["\u{61}\u{27}\u{2060}\u{308}\u{61}", "\u{3a}"]), ("\u{61}\u{27}\u{2060}\u{61}\u{27}",
+        &["\u{61}\u{27}\u{2060}\u{61}", "\u{27}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{61}\u{27}",
+        &["\u{61}\u{27}\u{2060}\u{308}\u{61}", "\u{27}"]),
+        ("\u{61}\u{27}\u{2060}\u{61}\u{27}\u{2060}", &["\u{61}\u{27}\u{2060}\u{61}",
+        "\u{27}\u{2060}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{61}\u{27}\u{2060}",
+        &["\u{61}\u{27}\u{2060}\u{308}\u{61}", "\u{27}\u{2060}"]),
+        ("\u{61}\u{27}\u{2060}\u{61}\u{2c}", &["\u{61}\u{27}\u{2060}\u{61}", "\u{2c}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{61}\u{2c}", &["\u{61}\u{27}\u{2060}\u{308}\u{61}",
+        "\u{2c}"]), ("\u{61}\u{27}\u{2060}\u{31}\u{3a}", &["\u{61}", "\u{27}\u{2060}", "\u{31}",
+        "\u{3a}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{31}\u{3a}", &["\u{61}", "\u{27}\u{2060}\u{308}",
+        "\u{31}", "\u{3a}"]), ("\u{61}\u{27}\u{2060}\u{31}\u{27}", &["\u{61}", "\u{27}\u{2060}",
+        "\u{31}", "\u{27}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{31}\u{27}", &["\u{61}",
+        "\u{27}\u{2060}\u{308}", "\u{31}", "\u{27}"]), ("\u{61}\u{27}\u{2060}\u{31}\u{2c}",
+        &["\u{61}", "\u{27}\u{2060}", "\u{31}", "\u{2c}"]),
+        ("\u{61}\u{27}\u{2060}\u{308}\u{31}\u{2c}", &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{31}",
+        "\u{2c}"]), ("\u{61}\u{27}\u{2060}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{27}\u{2060}",
+        "\u{31}", "\u{2e}\u{2060}"]), ("\u{61}\u{27}\u{2060}\u{308}\u{31}\u{2e}\u{2060}",
+        &["\u{61}", "\u{27}\u{2060}\u{308}", "\u{31}", "\u{2e}\u{2060}"]), ("\u{61}\u{2c}\u{1}",
+        &["\u{61}", "\u{2c}", "\u{1}"]), ("\u{61}\u{2c}\u{308}\u{1}", &["\u{61}", "\u{2c}\u{308}",
+        "\u{1}"]), ("\u{61}\u{2c}\u{d}", &["\u{61}", "\u{2c}", "\u{d}"]),
+        ("\u{61}\u{2c}\u{308}\u{d}", &["\u{61}", "\u{2c}\u{308}", "\u{d}"]), ("\u{61}\u{2c}\u{a}",
+        &["\u{61}", "\u{2c}", "\u{a}"]), ("\u{61}\u{2c}\u{308}\u{a}", &["\u{61}", "\u{2c}\u{308}",
+        "\u{a}"]), ("\u{61}\u{2c}\u{b}", &["\u{61}", "\u{2c}", "\u{b}"]),
+        ("\u{61}\u{2c}\u{308}\u{b}", &["\u{61}", "\u{2c}\u{308}", "\u{b}"]),
+        ("\u{61}\u{2c}\u{3031}", &["\u{61}", "\u{2c}", "\u{3031}"]), ("\u{61}\u{2c}\u{308}\u{3031}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{3031}"]), ("\u{61}\u{2c}\u{41}", &["\u{61}", "\u{2c}",
+        "\u{41}"]), ("\u{61}\u{2c}\u{308}\u{41}", &["\u{61}", "\u{2c}\u{308}", "\u{41}"]),
+        ("\u{61}\u{2c}\u{3a}", &["\u{61}", "\u{2c}", "\u{3a}"]), ("\u{61}\u{2c}\u{308}\u{3a}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{3a}"]), ("\u{61}\u{2c}\u{2c}", &["\u{61}", "\u{2c}",
+        "\u{2c}"]), ("\u{61}\u{2c}\u{308}\u{2c}", &["\u{61}", "\u{2c}\u{308}", "\u{2c}"]),
+        ("\u{61}\u{2c}\u{2e}", &["\u{61}", "\u{2c}", "\u{2e}"]), ("\u{61}\u{2c}\u{308}\u{2e}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{2e}"]), ("\u{61}\u{2c}\u{30}", &["\u{61}", "\u{2c}",
+        "\u{30}"]), ("\u{61}\u{2c}\u{308}\u{30}", &["\u{61}", "\u{2c}\u{308}", "\u{30}"]),
+        ("\u{61}\u{2c}\u{5f}", &["\u{61}", "\u{2c}", "\u{5f}"]), ("\u{61}\u{2c}\u{308}\u{5f}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{5f}"]), ("\u{61}\u{2c}\u{1f1e6}", &["\u{61}", "\u{2c}",
+        "\u{1f1e6}"]), ("\u{61}\u{2c}\u{308}\u{1f1e6}", &["\u{61}", "\u{2c}\u{308}", "\u{1f1e6}"]),
+        ("\u{61}\u{2c}\u{5d0}", &["\u{61}", "\u{2c}", "\u{5d0}"]), ("\u{61}\u{2c}\u{308}\u{5d0}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{5d0}"]), ("\u{61}\u{2c}\u{22}", &["\u{61}", "\u{2c}",
+        "\u{22}"]), ("\u{61}\u{2c}\u{308}\u{22}", &["\u{61}", "\u{2c}\u{308}", "\u{22}"]),
+        ("\u{61}\u{2c}\u{27}", &["\u{61}", "\u{2c}", "\u{27}"]), ("\u{61}\u{2c}\u{308}\u{27}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{27}"]), ("\u{61}\u{2c}\u{261d}", &["\u{61}", "\u{2c}",
+        "\u{261d}"]), ("\u{61}\u{2c}\u{308}\u{261d}", &["\u{61}", "\u{2c}\u{308}", "\u{261d}"]),
+        ("\u{61}\u{2c}\u{1f3fb}", &["\u{61}", "\u{2c}", "\u{1f3fb}"]),
+        ("\u{61}\u{2c}\u{308}\u{1f3fb}", &["\u{61}", "\u{2c}\u{308}", "\u{1f3fb}"]),
+        ("\u{61}\u{2c}\u{2764}", &["\u{61}", "\u{2c}", "\u{2764}"]), ("\u{61}\u{2c}\u{308}\u{2764}",
+        &["\u{61}", "\u{2c}\u{308}", "\u{2764}"]), ("\u{61}\u{2c}\u{1f466}", &["\u{61}", "\u{2c}",
+        "\u{1f466}"]), ("\u{61}\u{2c}\u{308}\u{1f466}", &["\u{61}", "\u{2c}\u{308}", "\u{1f466}"]),
+        ("\u{61}\u{2c}\u{ad}", &["\u{61}", "\u{2c}\u{ad}"]), ("\u{61}\u{2c}\u{308}\u{ad}",
+        &["\u{61}", "\u{2c}\u{308}\u{ad}"]), ("\u{61}\u{2c}\u{300}", &["\u{61}", "\u{2c}\u{300}"]),
+        ("\u{61}\u{2c}\u{308}\u{300}", &["\u{61}", "\u{2c}\u{308}\u{300}"]),
+        ("\u{61}\u{2c}\u{200d}", &["\u{61}", "\u{2c}\u{200d}"]), ("\u{61}\u{2c}\u{308}\u{200d}",
+        &["\u{61}", "\u{2c}\u{308}\u{200d}"]), ("\u{61}\u{2c}\u{61}\u{2060}", &["\u{61}", "\u{2c}",
+        "\u{61}\u{2060}"]), ("\u{61}\u{2c}\u{308}\u{61}\u{2060}", &["\u{61}", "\u{2c}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{61}\u{2c}\u{61}\u{3a}", &["\u{61}", "\u{2c}", "\u{61}", "\u{3a}"]),
+        ("\u{61}\u{2c}\u{308}\u{61}\u{3a}", &["\u{61}", "\u{2c}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{61}\u{2c}\u{61}\u{27}", &["\u{61}", "\u{2c}", "\u{61}", "\u{27}"]),
+        ("\u{61}\u{2c}\u{308}\u{61}\u{27}", &["\u{61}", "\u{2c}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{61}\u{2c}\u{61}\u{27}\u{2060}", &["\u{61}", "\u{2c}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{61}\u{2c}\u{308}\u{61}\u{27}\u{2060}", &["\u{61}", "\u{2c}\u{308}", "\u{61}",
+        "\u{27}\u{2060}"]), ("\u{61}\u{2c}\u{61}\u{2c}", &["\u{61}", "\u{2c}", "\u{61}", "\u{2c}"]),
+        ("\u{61}\u{2c}\u{308}\u{61}\u{2c}", &["\u{61}", "\u{2c}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{61}\u{2c}\u{31}\u{3a}", &["\u{61}", "\u{2c}", "\u{31}", "\u{3a}"]),
+        ("\u{61}\u{2c}\u{308}\u{31}\u{3a}", &["\u{61}", "\u{2c}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{61}\u{2c}\u{31}\u{27}", &["\u{61}", "\u{2c}", "\u{31}", "\u{27}"]),
+        ("\u{61}\u{2c}\u{308}\u{31}\u{27}", &["\u{61}", "\u{2c}\u{308}", "\u{31}", "\u{27}"]),
+        ("\u{61}\u{2c}\u{31}\u{2c}", &["\u{61}", "\u{2c}", "\u{31}", "\u{2c}"]),
+        ("\u{61}\u{2c}\u{308}\u{31}\u{2c}", &["\u{61}", "\u{2c}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{61}\u{2c}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{2c}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{61}\u{2c}\u{308}\u{31}\u{2e}\u{2060}", &["\u{61}", "\u{2c}\u{308}", "\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{31}\u{3a}\u{1}", &["\u{31}", "\u{3a}", "\u{1}"]),
+        ("\u{31}\u{3a}\u{308}\u{1}", &["\u{31}", "\u{3a}\u{308}", "\u{1}"]), ("\u{31}\u{3a}\u{d}",
+        &["\u{31}", "\u{3a}", "\u{d}"]), ("\u{31}\u{3a}\u{308}\u{d}", &["\u{31}", "\u{3a}\u{308}",
+        "\u{d}"]), ("\u{31}\u{3a}\u{a}", &["\u{31}", "\u{3a}", "\u{a}"]),
+        ("\u{31}\u{3a}\u{308}\u{a}", &["\u{31}", "\u{3a}\u{308}", "\u{a}"]), ("\u{31}\u{3a}\u{b}",
+        &["\u{31}", "\u{3a}", "\u{b}"]), ("\u{31}\u{3a}\u{308}\u{b}", &["\u{31}", "\u{3a}\u{308}",
+        "\u{b}"]), ("\u{31}\u{3a}\u{3031}", &["\u{31}", "\u{3a}", "\u{3031}"]),
+        ("\u{31}\u{3a}\u{308}\u{3031}", &["\u{31}", "\u{3a}\u{308}", "\u{3031}"]),
+        ("\u{31}\u{3a}\u{41}", &["\u{31}", "\u{3a}", "\u{41}"]), ("\u{31}\u{3a}\u{308}\u{41}",
+        &["\u{31}", "\u{3a}\u{308}", "\u{41}"]), ("\u{31}\u{3a}\u{3a}", &["\u{31}", "\u{3a}",
+        "\u{3a}"]), ("\u{31}\u{3a}\u{308}\u{3a}", &["\u{31}", "\u{3a}\u{308}", "\u{3a}"]),
+        ("\u{31}\u{3a}\u{2c}", &["\u{31}", "\u{3a}", "\u{2c}"]), ("\u{31}\u{3a}\u{308}\u{2c}",
+        &["\u{31}", "\u{3a}\u{308}", "\u{2c}"]), ("\u{31}\u{3a}\u{2e}", &["\u{31}", "\u{3a}",
+        "\u{2e}"]), ("\u{31}\u{3a}\u{308}\u{2e}", &["\u{31}", "\u{3a}\u{308}", "\u{2e}"]),
+        ("\u{31}\u{3a}\u{30}", &["\u{31}", "\u{3a}", "\u{30}"]), ("\u{31}\u{3a}\u{308}\u{30}",
+        &["\u{31}", "\u{3a}\u{308}", "\u{30}"]), ("\u{31}\u{3a}\u{5f}", &["\u{31}", "\u{3a}",
+        "\u{5f}"]), ("\u{31}\u{3a}\u{308}\u{5f}", &["\u{31}", "\u{3a}\u{308}", "\u{5f}"]),
+        ("\u{31}\u{3a}\u{1f1e6}", &["\u{31}", "\u{3a}", "\u{1f1e6}"]),
+        ("\u{31}\u{3a}\u{308}\u{1f1e6}", &["\u{31}", "\u{3a}\u{308}", "\u{1f1e6}"]),
+        ("\u{31}\u{3a}\u{5d0}", &["\u{31}", "\u{3a}", "\u{5d0}"]), ("\u{31}\u{3a}\u{308}\u{5d0}",
+        &["\u{31}", "\u{3a}\u{308}", "\u{5d0}"]), ("\u{31}\u{3a}\u{22}", &["\u{31}", "\u{3a}",
+        "\u{22}"]), ("\u{31}\u{3a}\u{308}\u{22}", &["\u{31}", "\u{3a}\u{308}", "\u{22}"]),
+        ("\u{31}\u{3a}\u{27}", &["\u{31}", "\u{3a}", "\u{27}"]), ("\u{31}\u{3a}\u{308}\u{27}",
+        &["\u{31}", "\u{3a}\u{308}", "\u{27}"]), ("\u{31}\u{3a}\u{261d}", &["\u{31}", "\u{3a}",
+        "\u{261d}"]), ("\u{31}\u{3a}\u{308}\u{261d}", &["\u{31}", "\u{3a}\u{308}", "\u{261d}"]),
+        ("\u{31}\u{3a}\u{1f3fb}", &["\u{31}", "\u{3a}", "\u{1f3fb}"]),
+        ("\u{31}\u{3a}\u{308}\u{1f3fb}", &["\u{31}", "\u{3a}\u{308}", "\u{1f3fb}"]),
+        ("\u{31}\u{3a}\u{2764}", &["\u{31}", "\u{3a}", "\u{2764}"]), ("\u{31}\u{3a}\u{308}\u{2764}",
+        &["\u{31}", "\u{3a}\u{308}", "\u{2764}"]), ("\u{31}\u{3a}\u{1f466}", &["\u{31}", "\u{3a}",
+        "\u{1f466}"]), ("\u{31}\u{3a}\u{308}\u{1f466}", &["\u{31}", "\u{3a}\u{308}", "\u{1f466}"]),
+        ("\u{31}\u{3a}\u{ad}", &["\u{31}", "\u{3a}\u{ad}"]), ("\u{31}\u{3a}\u{308}\u{ad}",
+        &["\u{31}", "\u{3a}\u{308}\u{ad}"]), ("\u{31}\u{3a}\u{300}", &["\u{31}", "\u{3a}\u{300}"]),
+        ("\u{31}\u{3a}\u{308}\u{300}", &["\u{31}", "\u{3a}\u{308}\u{300}"]),
+        ("\u{31}\u{3a}\u{200d}", &["\u{31}", "\u{3a}\u{200d}"]), ("\u{31}\u{3a}\u{308}\u{200d}",
+        &["\u{31}", "\u{3a}\u{308}\u{200d}"]), ("\u{31}\u{3a}\u{61}\u{2060}", &["\u{31}", "\u{3a}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{3a}\u{308}\u{61}\u{2060}", &["\u{31}", "\u{3a}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{3a}\u{61}\u{3a}", &["\u{31}", "\u{3a}", "\u{61}", "\u{3a}"]),
+        ("\u{31}\u{3a}\u{308}\u{61}\u{3a}", &["\u{31}", "\u{3a}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{31}\u{3a}\u{61}\u{27}", &["\u{31}", "\u{3a}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{3a}\u{308}\u{61}\u{27}", &["\u{31}", "\u{3a}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{3a}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{3a}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{31}\u{3a}\u{308}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{3a}\u{308}", "\u{61}",
+        "\u{27}\u{2060}"]), ("\u{31}\u{3a}\u{61}\u{2c}", &["\u{31}", "\u{3a}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{3a}\u{308}\u{61}\u{2c}", &["\u{31}", "\u{3a}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{3a}\u{31}\u{3a}", &["\u{31}", "\u{3a}", "\u{31}", "\u{3a}"]),
+        ("\u{31}\u{3a}\u{308}\u{31}\u{3a}", &["\u{31}", "\u{3a}\u{308}", "\u{31}", "\u{3a}"]),
+        ("\u{31}\u{3a}\u{31}\u{27}", &["\u{31}", "\u{3a}", "\u{31}", "\u{27}"]),
+        ("\u{31}\u{3a}\u{308}\u{31}\u{27}", &["\u{31}", "\u{3a}\u{308}", "\u{31}", "\u{27}"]),
+        ("\u{31}\u{3a}\u{31}\u{2c}", &["\u{31}", "\u{3a}", "\u{31}", "\u{2c}"]),
+        ("\u{31}\u{3a}\u{308}\u{31}\u{2c}", &["\u{31}", "\u{3a}\u{308}", "\u{31}", "\u{2c}"]),
+        ("\u{31}\u{3a}\u{31}\u{2e}\u{2060}", &["\u{31}", "\u{3a}", "\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{31}\u{3a}\u{308}\u{31}\u{2e}\u{2060}", &["\u{31}", "\u{3a}\u{308}", "\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{31}\u{27}\u{1}", &["\u{31}", "\u{27}", "\u{1}"]),
+        ("\u{31}\u{27}\u{308}\u{1}", &["\u{31}", "\u{27}\u{308}", "\u{1}"]), ("\u{31}\u{27}\u{d}",
+        &["\u{31}", "\u{27}", "\u{d}"]), ("\u{31}\u{27}\u{308}\u{d}", &["\u{31}", "\u{27}\u{308}",
+        "\u{d}"]), ("\u{31}\u{27}\u{a}", &["\u{31}", "\u{27}", "\u{a}"]),
+        ("\u{31}\u{27}\u{308}\u{a}", &["\u{31}", "\u{27}\u{308}", "\u{a}"]), ("\u{31}\u{27}\u{b}",
+        &["\u{31}", "\u{27}", "\u{b}"]), ("\u{31}\u{27}\u{308}\u{b}", &["\u{31}", "\u{27}\u{308}",
+        "\u{b}"]), ("\u{31}\u{27}\u{3031}", &["\u{31}", "\u{27}", "\u{3031}"]),
+        ("\u{31}\u{27}\u{308}\u{3031}", &["\u{31}", "\u{27}\u{308}", "\u{3031}"]),
+        ("\u{31}\u{27}\u{41}", &["\u{31}", "\u{27}", "\u{41}"]), ("\u{31}\u{27}\u{308}\u{41}",
+        &["\u{31}", "\u{27}\u{308}", "\u{41}"]), ("\u{31}\u{27}\u{3a}", &["\u{31}", "\u{27}",
+        "\u{3a}"]), ("\u{31}\u{27}\u{308}\u{3a}", &["\u{31}", "\u{27}\u{308}", "\u{3a}"]),
+        ("\u{31}\u{27}\u{2c}", &["\u{31}", "\u{27}", "\u{2c}"]), ("\u{31}\u{27}\u{308}\u{2c}",
+        &["\u{31}", "\u{27}\u{308}", "\u{2c}"]), ("\u{31}\u{27}\u{2e}", &["\u{31}", "\u{27}",
+        "\u{2e}"]), ("\u{31}\u{27}\u{308}\u{2e}", &["\u{31}", "\u{27}\u{308}", "\u{2e}"]),
+        ("\u{31}\u{27}\u{30}", &["\u{31}\u{27}\u{30}"]), ("\u{31}\u{27}\u{308}\u{30}",
+        &["\u{31}\u{27}\u{308}\u{30}"]), ("\u{31}\u{27}\u{5f}", &["\u{31}", "\u{27}", "\u{5f}"]),
+        ("\u{31}\u{27}\u{308}\u{5f}", &["\u{31}", "\u{27}\u{308}", "\u{5f}"]),
+        ("\u{31}\u{27}\u{1f1e6}", &["\u{31}", "\u{27}", "\u{1f1e6}"]),
+        ("\u{31}\u{27}\u{308}\u{1f1e6}", &["\u{31}", "\u{27}\u{308}", "\u{1f1e6}"]),
+        ("\u{31}\u{27}\u{5d0}", &["\u{31}", "\u{27}", "\u{5d0}"]), ("\u{31}\u{27}\u{308}\u{5d0}",
+        &["\u{31}", "\u{27}\u{308}", "\u{5d0}"]), ("\u{31}\u{27}\u{22}", &["\u{31}", "\u{27}",
+        "\u{22}"]), ("\u{31}\u{27}\u{308}\u{22}", &["\u{31}", "\u{27}\u{308}", "\u{22}"]),
+        ("\u{31}\u{27}\u{27}", &["\u{31}", "\u{27}", "\u{27}"]), ("\u{31}\u{27}\u{308}\u{27}",
+        &["\u{31}", "\u{27}\u{308}", "\u{27}"]), ("\u{31}\u{27}\u{261d}", &["\u{31}", "\u{27}",
+        "\u{261d}"]), ("\u{31}\u{27}\u{308}\u{261d}", &["\u{31}", "\u{27}\u{308}", "\u{261d}"]),
+        ("\u{31}\u{27}\u{1f3fb}", &["\u{31}", "\u{27}", "\u{1f3fb}"]),
+        ("\u{31}\u{27}\u{308}\u{1f3fb}", &["\u{31}", "\u{27}\u{308}", "\u{1f3fb}"]),
+        ("\u{31}\u{27}\u{2764}", &["\u{31}", "\u{27}", "\u{2764}"]), ("\u{31}\u{27}\u{308}\u{2764}",
+        &["\u{31}", "\u{27}\u{308}", "\u{2764}"]), ("\u{31}\u{27}\u{1f466}", &["\u{31}", "\u{27}",
+        "\u{1f466}"]), ("\u{31}\u{27}\u{308}\u{1f466}", &["\u{31}", "\u{27}\u{308}", "\u{1f466}"]),
+        ("\u{31}\u{27}\u{ad}", &["\u{31}", "\u{27}\u{ad}"]), ("\u{31}\u{27}\u{308}\u{ad}",
+        &["\u{31}", "\u{27}\u{308}\u{ad}"]), ("\u{31}\u{27}\u{300}", &["\u{31}", "\u{27}\u{300}"]),
+        ("\u{31}\u{27}\u{308}\u{300}", &["\u{31}", "\u{27}\u{308}\u{300}"]),
+        ("\u{31}\u{27}\u{200d}", &["\u{31}", "\u{27}\u{200d}"]), ("\u{31}\u{27}\u{308}\u{200d}",
+        &["\u{31}", "\u{27}\u{308}\u{200d}"]), ("\u{31}\u{27}\u{61}\u{2060}", &["\u{31}", "\u{27}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{27}\u{308}\u{61}\u{2060}", &["\u{31}", "\u{27}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{27}\u{61}\u{3a}", &["\u{31}", "\u{27}", "\u{61}", "\u{3a}"]),
+        ("\u{31}\u{27}\u{308}\u{61}\u{3a}", &["\u{31}", "\u{27}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{31}\u{27}\u{61}\u{27}", &["\u{31}", "\u{27}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{27}\u{308}\u{61}\u{27}", &["\u{31}", "\u{27}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{27}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{27}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{31}\u{27}\u{308}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{27}\u{308}", "\u{61}",
+        "\u{27}\u{2060}"]), ("\u{31}\u{27}\u{61}\u{2c}", &["\u{31}", "\u{27}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{27}\u{308}\u{61}\u{2c}", &["\u{31}", "\u{27}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{27}\u{31}\u{3a}", &["\u{31}\u{27}\u{31}", "\u{3a}"]),
+        ("\u{31}\u{27}\u{308}\u{31}\u{3a}", &["\u{31}\u{27}\u{308}\u{31}", "\u{3a}"]),
+        ("\u{31}\u{27}\u{31}\u{27}", &["\u{31}\u{27}\u{31}", "\u{27}"]),
+        ("\u{31}\u{27}\u{308}\u{31}\u{27}", &["\u{31}\u{27}\u{308}\u{31}", "\u{27}"]),
+        ("\u{31}\u{27}\u{31}\u{2c}", &["\u{31}\u{27}\u{31}", "\u{2c}"]),
+        ("\u{31}\u{27}\u{308}\u{31}\u{2c}", &["\u{31}\u{27}\u{308}\u{31}", "\u{2c}"]),
+        ("\u{31}\u{27}\u{31}\u{2e}\u{2060}", &["\u{31}\u{27}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{31}\u{27}\u{308}\u{31}\u{2e}\u{2060}", &["\u{31}\u{27}\u{308}\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{31}\u{2c}\u{1}", &["\u{31}", "\u{2c}", "\u{1}"]),
+        ("\u{31}\u{2c}\u{308}\u{1}", &["\u{31}", "\u{2c}\u{308}", "\u{1}"]), ("\u{31}\u{2c}\u{d}",
+        &["\u{31}", "\u{2c}", "\u{d}"]), ("\u{31}\u{2c}\u{308}\u{d}", &["\u{31}", "\u{2c}\u{308}",
+        "\u{d}"]), ("\u{31}\u{2c}\u{a}", &["\u{31}", "\u{2c}", "\u{a}"]),
+        ("\u{31}\u{2c}\u{308}\u{a}", &["\u{31}", "\u{2c}\u{308}", "\u{a}"]), ("\u{31}\u{2c}\u{b}",
+        &["\u{31}", "\u{2c}", "\u{b}"]), ("\u{31}\u{2c}\u{308}\u{b}", &["\u{31}", "\u{2c}\u{308}",
+        "\u{b}"]), ("\u{31}\u{2c}\u{3031}", &["\u{31}", "\u{2c}", "\u{3031}"]),
+        ("\u{31}\u{2c}\u{308}\u{3031}", &["\u{31}", "\u{2c}\u{308}", "\u{3031}"]),
+        ("\u{31}\u{2c}\u{41}", &["\u{31}", "\u{2c}", "\u{41}"]), ("\u{31}\u{2c}\u{308}\u{41}",
+        &["\u{31}", "\u{2c}\u{308}", "\u{41}"]), ("\u{31}\u{2c}\u{3a}", &["\u{31}", "\u{2c}",
+        "\u{3a}"]), ("\u{31}\u{2c}\u{308}\u{3a}", &["\u{31}", "\u{2c}\u{308}", "\u{3a}"]),
+        ("\u{31}\u{2c}\u{2c}", &["\u{31}", "\u{2c}", "\u{2c}"]), ("\u{31}\u{2c}\u{308}\u{2c}",
+        &["\u{31}", "\u{2c}\u{308}", "\u{2c}"]), ("\u{31}\u{2c}\u{2e}", &["\u{31}", "\u{2c}",
+        "\u{2e}"]), ("\u{31}\u{2c}\u{308}\u{2e}", &["\u{31}", "\u{2c}\u{308}", "\u{2e}"]),
+        ("\u{31}\u{2c}\u{30}", &["\u{31}\u{2c}\u{30}"]), ("\u{31}\u{2c}\u{308}\u{30}",
+        &["\u{31}\u{2c}\u{308}\u{30}"]), ("\u{31}\u{2c}\u{5f}", &["\u{31}", "\u{2c}", "\u{5f}"]),
+        ("\u{31}\u{2c}\u{308}\u{5f}", &["\u{31}", "\u{2c}\u{308}", "\u{5f}"]),
+        ("\u{31}\u{2c}\u{1f1e6}", &["\u{31}", "\u{2c}", "\u{1f1e6}"]),
+        ("\u{31}\u{2c}\u{308}\u{1f1e6}", &["\u{31}", "\u{2c}\u{308}", "\u{1f1e6}"]),
+        ("\u{31}\u{2c}\u{5d0}", &["\u{31}", "\u{2c}", "\u{5d0}"]), ("\u{31}\u{2c}\u{308}\u{5d0}",
+        &["\u{31}", "\u{2c}\u{308}", "\u{5d0}"]), ("\u{31}\u{2c}\u{22}", &["\u{31}", "\u{2c}",
+        "\u{22}"]), ("\u{31}\u{2c}\u{308}\u{22}", &["\u{31}", "\u{2c}\u{308}", "\u{22}"]),
+        ("\u{31}\u{2c}\u{27}", &["\u{31}", "\u{2c}", "\u{27}"]), ("\u{31}\u{2c}\u{308}\u{27}",
+        &["\u{31}", "\u{2c}\u{308}", "\u{27}"]), ("\u{31}\u{2c}\u{261d}", &["\u{31}", "\u{2c}",
+        "\u{261d}"]), ("\u{31}\u{2c}\u{308}\u{261d}", &["\u{31}", "\u{2c}\u{308}", "\u{261d}"]),
+        ("\u{31}\u{2c}\u{1f3fb}", &["\u{31}", "\u{2c}", "\u{1f3fb}"]),
+        ("\u{31}\u{2c}\u{308}\u{1f3fb}", &["\u{31}", "\u{2c}\u{308}", "\u{1f3fb}"]),
+        ("\u{31}\u{2c}\u{2764}", &["\u{31}", "\u{2c}", "\u{2764}"]), ("\u{31}\u{2c}\u{308}\u{2764}",
+        &["\u{31}", "\u{2c}\u{308}", "\u{2764}"]), ("\u{31}\u{2c}\u{1f466}", &["\u{31}", "\u{2c}",
+        "\u{1f466}"]), ("\u{31}\u{2c}\u{308}\u{1f466}", &["\u{31}", "\u{2c}\u{308}", "\u{1f466}"]),
+        ("\u{31}\u{2c}\u{ad}", &["\u{31}", "\u{2c}\u{ad}"]), ("\u{31}\u{2c}\u{308}\u{ad}",
+        &["\u{31}", "\u{2c}\u{308}\u{ad}"]), ("\u{31}\u{2c}\u{300}", &["\u{31}", "\u{2c}\u{300}"]),
+        ("\u{31}\u{2c}\u{308}\u{300}", &["\u{31}", "\u{2c}\u{308}\u{300}"]),
+        ("\u{31}\u{2c}\u{200d}", &["\u{31}", "\u{2c}\u{200d}"]), ("\u{31}\u{2c}\u{308}\u{200d}",
+        &["\u{31}", "\u{2c}\u{308}\u{200d}"]), ("\u{31}\u{2c}\u{61}\u{2060}", &["\u{31}", "\u{2c}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{2c}\u{308}\u{61}\u{2060}", &["\u{31}", "\u{2c}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{2c}\u{61}\u{3a}", &["\u{31}", "\u{2c}", "\u{61}", "\u{3a}"]),
+        ("\u{31}\u{2c}\u{308}\u{61}\u{3a}", &["\u{31}", "\u{2c}\u{308}", "\u{61}", "\u{3a}"]),
+        ("\u{31}\u{2c}\u{61}\u{27}", &["\u{31}", "\u{2c}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{2c}\u{308}\u{61}\u{27}", &["\u{31}", "\u{2c}\u{308}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{2c}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{2c}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{31}\u{2c}\u{308}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{2c}\u{308}", "\u{61}",
+        "\u{27}\u{2060}"]), ("\u{31}\u{2c}\u{61}\u{2c}", &["\u{31}", "\u{2c}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{2c}\u{308}\u{61}\u{2c}", &["\u{31}", "\u{2c}\u{308}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{2c}\u{31}\u{3a}", &["\u{31}\u{2c}\u{31}", "\u{3a}"]),
+        ("\u{31}\u{2c}\u{308}\u{31}\u{3a}", &["\u{31}\u{2c}\u{308}\u{31}", "\u{3a}"]),
+        ("\u{31}\u{2c}\u{31}\u{27}", &["\u{31}\u{2c}\u{31}", "\u{27}"]),
+        ("\u{31}\u{2c}\u{308}\u{31}\u{27}", &["\u{31}\u{2c}\u{308}\u{31}", "\u{27}"]),
+        ("\u{31}\u{2c}\u{31}\u{2c}", &["\u{31}\u{2c}\u{31}", "\u{2c}"]),
+        ("\u{31}\u{2c}\u{308}\u{31}\u{2c}", &["\u{31}\u{2c}\u{308}\u{31}", "\u{2c}"]),
+        ("\u{31}\u{2c}\u{31}\u{2e}\u{2060}", &["\u{31}\u{2c}\u{31}", "\u{2e}\u{2060}"]),
+        ("\u{31}\u{2c}\u{308}\u{31}\u{2e}\u{2060}", &["\u{31}\u{2c}\u{308}\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{31}\u{2e}\u{2060}\u{1}", &["\u{31}", "\u{2e}\u{2060}", "\u{1}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{1}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{1}"]),
+        ("\u{31}\u{2e}\u{2060}\u{d}", &["\u{31}", "\u{2e}\u{2060}", "\u{d}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{d}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{d}"]),
+        ("\u{31}\u{2e}\u{2060}\u{a}", &["\u{31}", "\u{2e}\u{2060}", "\u{a}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{a}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{a}"]),
+        ("\u{31}\u{2e}\u{2060}\u{b}", &["\u{31}", "\u{2e}\u{2060}", "\u{b}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{b}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{b}"]),
+        ("\u{31}\u{2e}\u{2060}\u{3031}", &["\u{31}", "\u{2e}\u{2060}", "\u{3031}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{3031}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{3031}"]),
+        ("\u{31}\u{2e}\u{2060}\u{41}", &["\u{31}", "\u{2e}\u{2060}", "\u{41}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{41}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{41}"]),
+        ("\u{31}\u{2e}\u{2060}\u{3a}", &["\u{31}", "\u{2e}\u{2060}", "\u{3a}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{3a}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{3a}"]),
+        ("\u{31}\u{2e}\u{2060}\u{2c}", &["\u{31}", "\u{2e}\u{2060}", "\u{2c}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{2c}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{2c}"]),
+        ("\u{31}\u{2e}\u{2060}\u{2e}", &["\u{31}", "\u{2e}\u{2060}", "\u{2e}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{2e}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{2e}"]),
+        ("\u{31}\u{2e}\u{2060}\u{30}", &["\u{31}\u{2e}\u{2060}\u{30}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{30}", &["\u{31}\u{2e}\u{2060}\u{308}\u{30}"]),
+        ("\u{31}\u{2e}\u{2060}\u{5f}", &["\u{31}", "\u{2e}\u{2060}", "\u{5f}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{5f}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{5f}"]),
+        ("\u{31}\u{2e}\u{2060}\u{1f1e6}", &["\u{31}", "\u{2e}\u{2060}", "\u{1f1e6}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{1f1e6}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{1f1e6}"]),
+        ("\u{31}\u{2e}\u{2060}\u{5d0}", &["\u{31}", "\u{2e}\u{2060}", "\u{5d0}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{5d0}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{5d0}"]),
+        ("\u{31}\u{2e}\u{2060}\u{22}", &["\u{31}", "\u{2e}\u{2060}", "\u{22}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{22}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{22}"]),
+        ("\u{31}\u{2e}\u{2060}\u{27}", &["\u{31}", "\u{2e}\u{2060}", "\u{27}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{27}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{27}"]),
+        ("\u{31}\u{2e}\u{2060}\u{261d}", &["\u{31}", "\u{2e}\u{2060}", "\u{261d}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{261d}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{261d}"]),
+        ("\u{31}\u{2e}\u{2060}\u{1f3fb}", &["\u{31}", "\u{2e}\u{2060}", "\u{1f3fb}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{1f3fb}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{1f3fb}"]),
+        ("\u{31}\u{2e}\u{2060}\u{2764}", &["\u{31}", "\u{2e}\u{2060}", "\u{2764}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{2764}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{2764}"]),
+        ("\u{31}\u{2e}\u{2060}\u{1f466}", &["\u{31}", "\u{2e}\u{2060}", "\u{1f466}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{1f466}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{1f466}"]),
+        ("\u{31}\u{2e}\u{2060}\u{ad}", &["\u{31}", "\u{2e}\u{2060}\u{ad}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{ad}", &["\u{31}", "\u{2e}\u{2060}\u{308}\u{ad}"]),
+        ("\u{31}\u{2e}\u{2060}\u{300}", &["\u{31}", "\u{2e}\u{2060}\u{300}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{300}", &["\u{31}", "\u{2e}\u{2060}\u{308}\u{300}"]),
+        ("\u{31}\u{2e}\u{2060}\u{200d}", &["\u{31}", "\u{2e}\u{2060}\u{200d}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{200d}", &["\u{31}", "\u{2e}\u{2060}\u{308}\u{200d}"]),
+        ("\u{31}\u{2e}\u{2060}\u{61}\u{2060}", &["\u{31}", "\u{2e}\u{2060}", "\u{61}\u{2060}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{61}\u{2060}", &["\u{31}", "\u{2e}\u{2060}\u{308}",
+        "\u{61}\u{2060}"]), ("\u{31}\u{2e}\u{2060}\u{61}\u{3a}", &["\u{31}", "\u{2e}\u{2060}",
+        "\u{61}", "\u{3a}"]), ("\u{31}\u{2e}\u{2060}\u{308}\u{61}\u{3a}", &["\u{31}",
+        "\u{2e}\u{2060}\u{308}", "\u{61}", "\u{3a}"]), ("\u{31}\u{2e}\u{2060}\u{61}\u{27}",
+        &["\u{31}", "\u{2e}\u{2060}", "\u{61}", "\u{27}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{61}\u{27}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{61}",
+        "\u{27}"]), ("\u{31}\u{2e}\u{2060}\u{61}\u{27}\u{2060}", &["\u{31}", "\u{2e}\u{2060}",
+        "\u{61}", "\u{27}\u{2060}"]), ("\u{31}\u{2e}\u{2060}\u{308}\u{61}\u{27}\u{2060}",
+        &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{61}", "\u{27}\u{2060}"]),
+        ("\u{31}\u{2e}\u{2060}\u{61}\u{2c}", &["\u{31}", "\u{2e}\u{2060}", "\u{61}", "\u{2c}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{61}\u{2c}", &["\u{31}", "\u{2e}\u{2060}\u{308}", "\u{61}",
+        "\u{2c}"]), ("\u{31}\u{2e}\u{2060}\u{31}\u{3a}", &["\u{31}\u{2e}\u{2060}\u{31}", "\u{3a}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{31}\u{3a}", &["\u{31}\u{2e}\u{2060}\u{308}\u{31}",
+        "\u{3a}"]), ("\u{31}\u{2e}\u{2060}\u{31}\u{27}", &["\u{31}\u{2e}\u{2060}\u{31}", "\u{27}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{31}\u{27}", &["\u{31}\u{2e}\u{2060}\u{308}\u{31}",
+        "\u{27}"]), ("\u{31}\u{2e}\u{2060}\u{31}\u{2c}", &["\u{31}\u{2e}\u{2060}\u{31}", "\u{2c}"]),
+        ("\u{31}\u{2e}\u{2060}\u{308}\u{31}\u{2c}", &["\u{31}\u{2e}\u{2060}\u{308}\u{31}",
+        "\u{2c}"]), ("\u{31}\u{2e}\u{2060}\u{31}\u{2e}\u{2060}", &["\u{31}\u{2e}\u{2060}\u{31}",
+        "\u{2e}\u{2060}"]), ("\u{31}\u{2e}\u{2060}\u{308}\u{31}\u{2e}\u{2060}",
+        &["\u{31}\u{2e}\u{2060}\u{308}\u{31}", "\u{2e}\u{2060}"]), ("\u{d}\u{a}\u{61}\u{a}\u{308}",
+        &["\u{d}\u{a}", "\u{61}", "\u{a}", "\u{308}"]), ("\u{61}\u{308}", &["\u{61}\u{308}"]),
+        ("\u{20}\u{200d}\u{646}", &["\u{20}\u{200d}", "\u{646}"]), ("\u{646}\u{200d}\u{20}",
+        &["\u{646}\u{200d}", "\u{20}"]), ("\u{41}\u{41}\u{41}", &["\u{41}\u{41}\u{41}"]),
+        ("\u{41}\u{3a}\u{41}", &["\u{41}\u{3a}\u{41}"]), ("\u{41}\u{3a}\u{3a}\u{41}", &["\u{41}",
+        "\u{3a}", "\u{3a}", "\u{41}"]), ("\u{5d0}\u{27}", &["\u{5d0}\u{27}"]),
+        ("\u{5d0}\u{22}\u{5d0}", &["\u{5d0}\u{22}\u{5d0}"]), ("\u{41}\u{30}\u{30}\u{41}",
+        &["\u{41}\u{30}\u{30}\u{41}"]), ("\u{30}\u{2c}\u{30}", &["\u{30}\u{2c}\u{30}"]),
+        ("\u{30}\u{2c}\u{2c}\u{30}", &["\u{30}", "\u{2c}", "\u{2c}", "\u{30}"]),
+        ("\u{3031}\u{3031}", &["\u{3031}\u{3031}"]), ("\u{41}\u{5f}\u{30}\u{5f}\u{3031}\u{5f}",
+        &["\u{41}\u{5f}\u{30}\u{5f}\u{3031}\u{5f}"]), ("\u{41}\u{5f}\u{5f}\u{41}",
+        &["\u{41}\u{5f}\u{5f}\u{41}"]), ("\u{1f1e6}\u{1f1e7}\u{1f1e8}\u{62}",
+        &["\u{1f1e6}\u{1f1e7}", "\u{1f1e8}", "\u{62}"]), ("\u{61}\u{1f1e6}\u{1f1e7}\u{1f1e8}\u{62}",
+        &["\u{61}", "\u{1f1e6}\u{1f1e7}", "\u{1f1e8}", "\u{62}"]),
+        ("\u{61}\u{1f1e6}\u{1f1e7}\u{200d}\u{1f1e8}\u{62}", &["\u{61}",
+        "\u{1f1e6}\u{1f1e7}\u{200d}", "\u{1f1e8}", "\u{62}"]),
+        ("\u{61}\u{1f1e6}\u{200d}\u{1f1e7}\u{1f1e8}\u{62}", &["\u{61}",
+        "\u{1f1e6}\u{200d}\u{1f1e7}", "\u{1f1e8}", "\u{62}"]),
+        ("\u{61}\u{1f1e6}\u{1f1e7}\u{1f1e8}\u{1f1e9}\u{62}", &["\u{61}", "\u{1f1e6}\u{1f1e7}",
+        "\u{1f1e8}\u{1f1e9}", "\u{62}"]), ("\u{261d}\u{1f3fb}\u{261d}", &["\u{261d}\u{1f3fb}",
+        "\u{261d}"]), ("\u{1f466}\u{1f3fb}", &["\u{1f466}\u{1f3fb}"]),
+        ("\u{200d}\u{1f466}\u{1f3fb}", &["\u{200d}\u{1f466}\u{1f3fb}"]), ("\u{200d}\u{2764}",
+        &["\u{200d}\u{2764}"]), ("\u{200d}\u{1f466}", &["\u{200d}\u{1f466}"]),
+        ("\u{1f466}\u{1f466}", &["\u{1f466}", "\u{1f466}"]), ("\u{61}\u{308}\u{200d}\u{308}\u{62}",
+        &["\u{61}\u{308}\u{200d}\u{308}\u{62}"]), ("\u{31}\u{3a}\u{3a}\u{31}", &["\u{31}", "\u{3a}",
+        "\u{3a}", "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{3a}\u{3a}\u{31}", &["\u{31}\u{5f}\u{31}",
+        "\u{3a}", "\u{3a}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{3a}\u{3a}\u{31}",
+        &["\u{31}\u{5f}\u{61}", "\u{3a}", "\u{3a}", "\u{31}"]), ("\u{31}\u{3a}\u{3a}\u{61}",
+        &["\u{31}", "\u{3a}", "\u{3a}", "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{3a}\u{3a}\u{61}",
+        &["\u{31}\u{5f}\u{31}", "\u{3a}", "\u{3a}", "\u{61}"]),
+        ("\u{31}\u{5f}\u{61}\u{3a}\u{3a}\u{61}", &["\u{31}\u{5f}\u{61}", "\u{3a}", "\u{3a}",
+        "\u{61}"]), ("\u{31}\u{3a}\u{2e}\u{31}", &["\u{31}", "\u{3a}", "\u{2e}", "\u{31}"]),
+        ("\u{31}\u{5f}\u{31}\u{3a}\u{2e}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{3a}", "\u{2e}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{3a}\u{2e}\u{31}", &["\u{31}\u{5f}\u{61}", "\u{3a}",
+        "\u{2e}", "\u{31}"]), ("\u{31}\u{3a}\u{2e}\u{61}", &["\u{31}", "\u{3a}", "\u{2e}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{3a}\u{2e}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{3a}",
+        "\u{2e}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{3a}\u{2e}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{3a}", "\u{2e}", "\u{61}"]), ("\u{31}\u{3a}\u{2c}\u{31}", &["\u{31}", "\u{3a}", "\u{2c}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{3a}\u{2c}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{3a}",
+        "\u{2c}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{3a}\u{2c}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{3a}", "\u{2c}", "\u{31}"]), ("\u{31}\u{3a}\u{2c}\u{61}", &["\u{31}", "\u{3a}", "\u{2c}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{3a}\u{2c}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{3a}",
+        "\u{2c}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{3a}\u{2c}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{3a}", "\u{2c}", "\u{61}"]), ("\u{31}\u{2e}\u{3a}\u{31}", &["\u{31}", "\u{2e}", "\u{3a}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{2e}\u{3a}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{2e}",
+        "\u{3a}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{2e}\u{3a}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{2e}", "\u{3a}", "\u{31}"]), ("\u{31}\u{2e}\u{3a}\u{61}", &["\u{31}", "\u{2e}", "\u{3a}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{2e}\u{3a}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{2e}",
+        "\u{3a}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{2e}\u{3a}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{2e}", "\u{3a}", "\u{61}"]), ("\u{31}\u{2e}\u{2e}\u{31}", &["\u{31}", "\u{2e}", "\u{2e}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{2e}\u{2e}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{2e}",
+        "\u{2e}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{2e}\u{2e}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{2e}", "\u{2e}", "\u{31}"]), ("\u{31}\u{2e}\u{2e}\u{61}", &["\u{31}", "\u{2e}", "\u{2e}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{2e}\u{2e}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{2e}",
+        "\u{2e}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{2e}\u{2e}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{2e}", "\u{2e}", "\u{61}"]), ("\u{31}\u{2e}\u{2c}\u{31}", &["\u{31}", "\u{2e}", "\u{2c}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{2e}\u{2c}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{2e}",
+        "\u{2c}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{2e}\u{2c}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{2e}", "\u{2c}", "\u{31}"]), ("\u{31}\u{2e}\u{2c}\u{61}", &["\u{31}", "\u{2e}", "\u{2c}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{2e}\u{2c}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{2e}",
+        "\u{2c}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{2e}\u{2c}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{2e}", "\u{2c}", "\u{61}"]), ("\u{31}\u{2c}\u{3a}\u{31}", &["\u{31}", "\u{2c}", "\u{3a}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{2c}\u{3a}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{2c}",
+        "\u{3a}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{2c}\u{3a}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{2c}", "\u{3a}", "\u{31}"]), ("\u{31}\u{2c}\u{3a}\u{61}", &["\u{31}", "\u{2c}", "\u{3a}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{2c}\u{3a}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{2c}",
+        "\u{3a}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{2c}\u{3a}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{2c}", "\u{3a}", "\u{61}"]), ("\u{31}\u{2c}\u{2e}\u{31}", &["\u{31}", "\u{2c}", "\u{2e}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{2c}\u{2e}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{2c}",
+        "\u{2e}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{2c}\u{2e}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{2c}", "\u{2e}", "\u{31}"]), ("\u{31}\u{2c}\u{2e}\u{61}", &["\u{31}", "\u{2c}", "\u{2e}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{2c}\u{2e}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{2c}",
+        "\u{2e}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{2c}\u{2e}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{2c}", "\u{2e}", "\u{61}"]), ("\u{31}\u{2c}\u{2c}\u{31}", &["\u{31}", "\u{2c}", "\u{2c}",
+        "\u{31}"]), ("\u{31}\u{5f}\u{31}\u{2c}\u{2c}\u{31}", &["\u{31}\u{5f}\u{31}", "\u{2c}",
+        "\u{2c}", "\u{31}"]), ("\u{31}\u{5f}\u{61}\u{2c}\u{2c}\u{31}", &["\u{31}\u{5f}\u{61}",
+        "\u{2c}", "\u{2c}", "\u{31}"]), ("\u{31}\u{2c}\u{2c}\u{61}", &["\u{31}", "\u{2c}", "\u{2c}",
+        "\u{61}"]), ("\u{31}\u{5f}\u{31}\u{2c}\u{2c}\u{61}", &["\u{31}\u{5f}\u{31}", "\u{2c}",
+        "\u{2c}", "\u{61}"]), ("\u{31}\u{5f}\u{61}\u{2c}\u{2c}\u{61}", &["\u{31}\u{5f}\u{61}",
+        "\u{2c}", "\u{2c}", "\u{61}"]), ("\u{61}\u{3a}\u{3a}\u{31}", &["\u{61}", "\u{3a}", "\u{3a}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{3a}\u{3a}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{3a}",
+        "\u{3a}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{3a}\u{3a}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{3a}", "\u{3a}", "\u{31}"]), ("\u{61}\u{3a}\u{3a}\u{61}", &["\u{61}", "\u{3a}", "\u{3a}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{3a}\u{3a}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{3a}",
+        "\u{3a}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{3a}\u{3a}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{3a}", "\u{3a}", "\u{61}"]), ("\u{61}\u{3a}\u{2e}\u{31}", &["\u{61}", "\u{3a}", "\u{2e}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{3a}\u{2e}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{3a}",
+        "\u{2e}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{3a}\u{2e}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{3a}", "\u{2e}", "\u{31}"]), ("\u{61}\u{3a}\u{2e}\u{61}", &["\u{61}", "\u{3a}", "\u{2e}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{3a}\u{2e}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{3a}",
+        "\u{2e}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{3a}\u{2e}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{3a}", "\u{2e}", "\u{61}"]), ("\u{61}\u{3a}\u{2c}\u{31}", &["\u{61}", "\u{3a}", "\u{2c}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{3a}\u{2c}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{3a}",
+        "\u{2c}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{3a}\u{2c}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{3a}", "\u{2c}", "\u{31}"]), ("\u{61}\u{3a}\u{2c}\u{61}", &["\u{61}", "\u{3a}", "\u{2c}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{3a}\u{2c}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{3a}",
+        "\u{2c}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{3a}\u{2c}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{3a}", "\u{2c}", "\u{61}"]), ("\u{61}\u{2e}\u{3a}\u{31}", &["\u{61}", "\u{2e}", "\u{3a}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{2e}\u{3a}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{2e}",
+        "\u{3a}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{2e}\u{3a}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{2e}", "\u{3a}", "\u{31}"]), ("\u{61}\u{2e}\u{3a}\u{61}", &["\u{61}", "\u{2e}", "\u{3a}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{2e}\u{3a}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{2e}",
+        "\u{3a}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{2e}\u{3a}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{2e}", "\u{3a}", "\u{61}"]), ("\u{61}\u{2e}\u{2e}\u{31}", &["\u{61}", "\u{2e}", "\u{2e}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{2e}\u{2e}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{2e}",
+        "\u{2e}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{2e}\u{2e}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{2e}", "\u{2e}", "\u{31}"]), ("\u{61}\u{2e}\u{2e}\u{61}", &["\u{61}", "\u{2e}", "\u{2e}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{2e}\u{2e}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{2e}",
+        "\u{2e}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{2e}\u{2e}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{2e}", "\u{2e}", "\u{61}"]), ("\u{61}\u{2e}\u{2c}\u{31}", &["\u{61}", "\u{2e}", "\u{2c}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{2e}\u{2c}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{2e}",
+        "\u{2c}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{2e}\u{2c}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{2e}", "\u{2c}", "\u{31}"]), ("\u{61}\u{2e}\u{2c}\u{61}", &["\u{61}", "\u{2e}", "\u{2c}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{2e}\u{2c}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{2e}",
+        "\u{2c}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{2e}\u{2c}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{2e}", "\u{2c}", "\u{61}"]), ("\u{61}\u{2c}\u{3a}\u{31}", &["\u{61}", "\u{2c}", "\u{3a}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{2c}\u{3a}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{2c}",
+        "\u{3a}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{2c}\u{3a}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{2c}", "\u{3a}", "\u{31}"]), ("\u{61}\u{2c}\u{3a}\u{61}", &["\u{61}", "\u{2c}", "\u{3a}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{2c}\u{3a}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{2c}",
+        "\u{3a}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{2c}\u{3a}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{2c}", "\u{3a}", "\u{61}"]), ("\u{61}\u{2c}\u{2e}\u{31}", &["\u{61}", "\u{2c}", "\u{2e}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{2c}\u{2e}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{2c}",
+        "\u{2e}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{2c}\u{2e}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{2c}", "\u{2e}", "\u{31}"]), ("\u{61}\u{2c}\u{2e}\u{61}", &["\u{61}", "\u{2c}", "\u{2e}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{2c}\u{2e}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{2c}",
+        "\u{2e}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{2c}\u{2e}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{2c}", "\u{2e}", "\u{61}"]), ("\u{61}\u{2c}\u{2c}\u{31}", &["\u{61}", "\u{2c}", "\u{2c}",
+        "\u{31}"]), ("\u{61}\u{5f}\u{31}\u{2c}\u{2c}\u{31}", &["\u{61}\u{5f}\u{31}", "\u{2c}",
+        "\u{2c}", "\u{31}"]), ("\u{61}\u{5f}\u{61}\u{2c}\u{2c}\u{31}", &["\u{61}\u{5f}\u{61}",
+        "\u{2c}", "\u{2c}", "\u{31}"]), ("\u{61}\u{2c}\u{2c}\u{61}", &["\u{61}", "\u{2c}", "\u{2c}",
+        "\u{61}"]), ("\u{61}\u{5f}\u{31}\u{2c}\u{2c}\u{61}", &["\u{61}\u{5f}\u{31}", "\u{2c}",
+        "\u{2c}", "\u{61}"]), ("\u{61}\u{5f}\u{61}\u{2c}\u{2c}\u{61}", &["\u{61}\u{5f}\u{61}",
+        "\u{2c}", "\u{2c}", "\u{61}"])
+    ];
+
diff --git a/rustc_deps/vendor/unicode-segmentation/src/word.rs b/rustc_deps/vendor/unicode-segmentation/src/word.rs
new file mode 100644
index 0000000..436582c
--- /dev/null
+++ b/rustc_deps/vendor/unicode-segmentation/src/word.rs
@@ -0,0 +1,649 @@
+// Copyright 2012-2014 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::cmp;
+use core::iter::Filter;
+
+use tables::word::WordCat;
+
+/// An iterator over the substrings of a string which, after splitting the string on
+/// [word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries),
+/// contain any characters with the
+/// [Alphabetic](http://unicode.org/reports/tr44/#Alphabetic)
+/// property, or with
+/// [General_Category=Number](http://unicode.org/reports/tr44/#General_Category_Values).
+pub struct UnicodeWords<'a> {
+    inner: Filter<UWordBounds<'a>, fn(&&str) -> bool>,
+}
+
+impl<'a> Iterator for UnicodeWords<'a> {
+    type Item = &'a str;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'a str> { self.inner.next() }
+}
+impl<'a> DoubleEndedIterator for UnicodeWords<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
+}
+
+/// External iterator for a string's
+/// [word boundaries](http://www.unicode.org/reports/tr29/#Word_Boundaries).
+#[derive(Clone)]
+pub struct UWordBounds<'a> {
+    string: &'a str,
+    cat: Option<WordCat>,
+    catb: Option<WordCat>,
+}
+
+/// External iterator for word boundaries and byte offsets.
+#[derive(Clone)]
+pub struct UWordBoundIndices<'a> {
+    start_offset: usize,
+    iter: UWordBounds<'a>,
+}
+
+impl<'a> UWordBoundIndices<'a> {
+    #[inline]
+    /// View the underlying data (the part yet to be iterated) as a slice of the original string.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::UnicodeSegmentation;
+    /// let mut iter = "Hello world".split_word_bound_indices();
+    /// assert_eq!(iter.as_str(), "Hello world");
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), " world");
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), "world");
+    /// ```
+    pub fn as_str(&self) -> &'a str {
+        self.iter.as_str()
+    }
+}
+
+impl<'a> Iterator for UWordBoundIndices<'a> {
+    type Item = (usize, &'a str);
+
+    #[inline]
+    fn next(&mut self) -> Option<(usize, &'a str)> {
+        self.iter.next().map(|s| (s.as_ptr() as usize - self.start_offset, s))
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<'a> DoubleEndedIterator for UWordBoundIndices<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<(usize, &'a str)> {
+        self.iter.next_back().map(|s| (s.as_ptr() as usize - self.start_offset, s))
+    }
+}
+
+// state machine for word boundary rules
+#[derive(Clone,Copy,PartialEq,Eq,Debug)]
+enum UWordBoundsState {
+    Start,
+    Letter,
+    HLetter,
+    Numeric,
+    Katakana,
+    ExtendNumLet,
+    Regional(RegionalState),
+    FormatExtend(FormatExtendType),
+    Zwj,
+    Emoji,
+}
+
+// subtypes for FormatExtend state in UWordBoundsState
+#[derive(Clone,Copy,PartialEq,Eq,Debug)]
+enum FormatExtendType {
+    AcceptAny,
+    AcceptNone,
+    RequireLetter,
+    RequireHLetter,
+    AcceptQLetter,
+    RequireNumeric,
+}
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug)]
+enum RegionalState {
+    Half,
+    Full,
+    Unknown,
+}
+
+impl<'a> Iterator for UWordBounds<'a> {
+    type Item = &'a str;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let slen = self.string.len();
+        (cmp::min(slen, 1), Some(slen))
+    }
+
+    #[inline]
+    fn next(&mut self) -> Option<&'a str> {
+        use self::UWordBoundsState::*;
+        use self::FormatExtendType::*;
+        use tables::word as wd;
+        if self.string.len() == 0 {
+            return None;
+        }
+
+        let mut take_curr = true;
+        let mut take_cat = true;
+        let mut idx = 0;
+        let mut saveidx = 0;
+        let mut state = Start;
+        let mut cat = wd::WC_Any;
+        let mut savecat = wd::WC_Any;
+
+        // Whether or not the previous category was ZWJ
+        // ZWJs get collapsed, so this handles precedence of WB3c over WB4
+        let mut prev_zwj;
+        for (curr, ch) in self.string.char_indices() {
+            idx = curr;
+            prev_zwj = cat == wd::WC_ZWJ;
+            // if there's a category cached, grab it
+            cat = match self.cat {
+                None => wd::word_category(ch),
+                _ => self.cat.take().unwrap()
+            };
+            take_cat = true;
+
+            // handle rule WB4
+            // just skip all format, extend, and zwj chars
+            // note that Start is a special case: if there's a bunch of Format | Extend
+            // characters at the beginning of a block of text, dump them out as one unit.
+            //
+            // (This is not obvious from the wording of UAX#29, but if you look at the
+            // test cases http://www.unicode.org/Public/UNIDATA/auxiliary/WordBreakTest.txt
+            // then the "correct" interpretation of WB4 becomes apparent.)
+            if state != Start {
+                match cat {
+                    wd::WC_Extend | wd::WC_Format | wd::WC_ZWJ => {
+                        continue
+                    }
+                    _ => {}
+                }
+            }
+
+            // rule WB3c
+            // WB4 makes all ZWJs collapse into the previous state
+            // but you can still be in a Zwj state if you started with Zwj
+            //
+            // This means that Zwj + Extend will collapse into Zwj, which is wrong,
+            // since Extend has a boundary with following EBG/GAZ chars but ZWJ doesn't,
+            // and that rule (WB3c) has higher priority
+            //
+            // Additionally, Emoji_Base+ZWJ+(EBG/GAZ) will collapse into Emoji_Base+EBG/GAZ
+            // which won't have a boundary even though EB+ZWJ+GAZ should have a boundary.
+            //
+            // Thus, we separately keep track of whether or not the last character
+            // was a ZWJ. This is an additional bit of state tracked outside of the
+            // state enum; the state enum represents the last non-zwj state encountered.
+            // When prev_zwj is true, for the purposes of WB3c, we are in the Zwj state,
+            // however we are in the previous state for the purposes of all other rules.
+            if prev_zwj {
+                match cat { 
+                    wd::WC_Glue_After_Zwj => continue,
+                    wd::WC_E_Base_GAZ => {
+                        state = Emoji;
+                        continue;
+                    },
+                    _ => ()
+                }
+            }
+            // Don't use `continue` in this match without updating `cat`
+            state = match state {
+                Start if cat == wd::WC_CR => {
+                    idx += match self.get_next_cat(idx) {
+                        Some(ncat) if ncat == wd::WC_LF => 1,       // rule WB3
+                        _ => 0
+                    };
+                    break;                                          // rule WB3a
+                },
+                Start => match cat {
+                    wd::WC_ALetter => Letter,           // rule WB5, WB6, WB9, WB13a
+                    wd::WC_Hebrew_Letter => HLetter,    // rule WB5, WB6, WB7a, WB7b, WB9, WB13a
+                    wd::WC_Numeric => Numeric,          // rule WB8, WB10, WB12, WB13a
+                    wd::WC_Katakana => Katakana,        // rule WB13, WB13a
+                    wd::WC_ExtendNumLet => ExtendNumLet,    // rule WB13a, WB13b
+                    wd::WC_Regional_Indicator => Regional(RegionalState::Half),  // rule WB13c
+                    wd::WC_LF | wd::WC_Newline => break,    // rule WB3a
+                    wd::WC_ZWJ => Zwj,                      // rule WB3c
+                    wd::WC_E_Base | wd::WC_E_Base_GAZ => Emoji, // rule WB14
+                    _ => {
+                        if let Some(ncat) = self.get_next_cat(idx) {                // rule WB4
+                            if ncat == wd::WC_Format || ncat == wd::WC_Extend || ncat == wd::WC_ZWJ {
+                                state = FormatExtend(AcceptNone);
+                                self.cat = Some(ncat);
+                                continue;
+                            }
+                        }
+                        break;                                                      // rule WB999
+                    }
+                },
+                Zwj => {
+                    // We already handle WB3c above. At this point,
+                    // the current category is not GAZ or EBG,
+                    // or the previous character was not actually a ZWJ
+                    take_curr = false;
+                    break;
+                }
+                Letter | HLetter => match cat {
+                    wd::WC_ALetter => Letter,                   // rule WB5
+                    wd::WC_Hebrew_Letter => HLetter,            // rule WB5
+                    wd::WC_Numeric => Numeric,                  // rule WB9
+                    wd::WC_ExtendNumLet => ExtendNumLet,        // rule WB13a
+                    wd::WC_Double_Quote if state == HLetter => {
+                        savecat = cat;
+                        saveidx = idx;
+                        FormatExtend(RequireHLetter)                        // rule WB7b
+                    },
+                    wd::WC_Single_Quote if state == HLetter => {
+                        FormatExtend(AcceptQLetter)                         // rule WB7a
+                    },
+                    wd::WC_MidLetter | wd::WC_MidNumLet | wd::WC_Single_Quote => {
+                        savecat = cat;
+                        saveidx = idx;
+                        FormatExtend(RequireLetter)                         // rule WB6
+                    },
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Numeric => match cat {
+                    wd::WC_Numeric => Numeric,                  // rule WB8
+                    wd::WC_ALetter => Letter,                   // rule WB10
+                    wd::WC_Hebrew_Letter => HLetter,            // rule WB10
+                    wd::WC_ExtendNumLet => ExtendNumLet,        // rule WB13a
+                    wd::WC_MidNum | wd::WC_MidNumLet | wd::WC_Single_Quote => {
+                        savecat = cat;
+                        saveidx = idx;
+                        FormatExtend(RequireNumeric)            // rule WB12
+                    },
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Katakana => match cat {
+                    wd::WC_Katakana => Katakana,                // rule WB13
+                    wd::WC_ExtendNumLet => ExtendNumLet,        // rule WB13a
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                ExtendNumLet => match cat {
+                    wd::WC_ExtendNumLet => ExtendNumLet,        // rule WB13a
+                    wd::WC_ALetter => Letter,                   // rule WB13b
+                    wd::WC_Hebrew_Letter => HLetter,            // rule WB13b
+                    wd::WC_Numeric => Numeric,                  // rule WB13b
+                    wd::WC_Katakana => Katakana,                // rule WB13b
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Regional(RegionalState::Full) => {
+                    // if it reaches here we've gone too far,
+                    // a full flag can only compose with ZWJ/Extend/Format
+                    // proceeding it.
+                    take_curr = false;
+                    break;
+                }
+                Regional(RegionalState::Half) => match cat {
+                    wd::WC_Regional_Indicator => Regional(RegionalState::Full),      // rule WB13c
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Regional(_) => unreachable!("RegionalState::Unknown should not occur on forward iteration"),
+                Emoji => match cat {                            // rule WB14
+                    wd::WC_E_Modifier => state,
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                FormatExtend(t) => match t {    // handle FormatExtends depending on what type
+                    RequireNumeric if cat == wd::WC_Numeric => Numeric,     // rule WB11
+                    RequireLetter | AcceptQLetter if cat == wd::WC_ALetter => Letter,   // rule WB7
+                    RequireLetter | AcceptQLetter if cat == wd::WC_Hebrew_Letter => HLetter, // WB7a
+                    RequireHLetter if cat == wd::WC_Hebrew_Letter => HLetter,   // rule WB7b
+                    AcceptNone | AcceptQLetter => {
+                        take_curr = false;  // emit all the Format|Extend characters
+                        take_cat = false;
+                        break;
+                    },
+                    _ => break      // rewind (in if statement below)
+                }
+            }
+        }
+
+        if let FormatExtend(t) = state {
+            // we were looking for something and didn't find it; we have to back up
+            if t == RequireLetter || t == RequireHLetter || t == RequireNumeric {
+                idx = saveidx;
+                cat = savecat;
+                take_curr = false;
+            }
+        }
+
+        self.cat = if take_curr {
+            idx = idx + self.string[idx..].chars().next().unwrap().len_utf8();
+            None
+        } else if take_cat {
+            Some(cat)
+        } else {
+            None
+        };
+
+        let retstr = &self.string[..idx];
+        self.string = &self.string[idx..];
+        Some(retstr)
+    }
+}
+
+impl<'a> DoubleEndedIterator for UWordBounds<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a str> {
+        use self::UWordBoundsState::*;
+        use self::FormatExtendType::*;
+        use tables::word as wd;
+        if self.string.len() == 0 {
+            return None;
+        }
+
+        let mut take_curr = true;
+        let mut take_cat = true;
+        let mut idx = self.string.len();
+        idx -= self.string.chars().next_back().unwrap().len_utf8();
+        let mut previdx = idx;
+        let mut saveidx = idx;
+        let mut state = Start;
+        let mut savestate = Start;
+        let mut cat = wd::WC_Any;
+
+        for (curr, ch) in self.string.char_indices().rev() {
+            previdx = idx;
+            idx = curr;
+
+            // if there's a category cached, grab it
+            cat = match self.catb {
+                None => wd::word_category(ch),
+                _ => self.catb.take().unwrap()
+            };
+            take_cat = true;
+
+            // backward iterator over word boundaries. Mostly the same as the forward
+            // iterator, with two weirdnesses:
+            // (1) If we encounter a single quote in the Start state, we have to check for a
+            //     Hebrew Letter immediately before it.
+            // (2) Format and Extend char handling takes some gymnastics.
+
+            if cat == wd::WC_Extend
+                || cat == wd::WC_Format
+                || (cat == wd::WC_ZWJ && state != Zwj) { // WB3c has more priority so we should not
+                                                         // fold in that case
+                if match state {
+                    FormatExtend(_) | Start => false,
+                    _ => true
+                } {
+                    saveidx = previdx;
+                    savestate = state;
+                    state = FormatExtend(AcceptNone);
+                }
+
+                if state != Start {
+                    continue;
+                }
+            } else if state == FormatExtend(AcceptNone) {
+                // finished a scan of some Format|Extend chars, restore previous state
+                state = savestate;
+                previdx = saveidx;
+                take_cat = false;
+            }
+
+            // Don't use `continue` in this match without updating `catb`
+            state = match state {
+                Start | FormatExtend(AcceptAny) => match cat {
+                    wd::WC_ALetter => Letter,           // rule WB5, WB7, WB10, WB13b
+                    wd::WC_Hebrew_Letter => HLetter,    // rule WB5, WB7, WB7c, WB10, WB13b
+                    wd::WC_Numeric => Numeric,          // rule WB8, WB9, WB11, WB13b
+                    wd::WC_Katakana => Katakana,                    // rule WB13, WB13b
+                    wd::WC_ExtendNumLet => ExtendNumLet,                    // rule WB13a
+                    wd::WC_Regional_Indicator => Regional(RegionalState::Unknown), // rule WB13c
+                    wd::WC_Glue_After_Zwj | wd::WC_E_Base_GAZ => Zwj,       // rule WB3c
+                    // rule WB4:
+                    wd::WC_Extend | wd::WC_Format | wd::WC_ZWJ => FormatExtend(AcceptAny),
+                    wd::WC_Single_Quote => {
+                        saveidx = idx;
+                        FormatExtend(AcceptQLetter)                         // rule WB7a
+                    },
+                    wd::WC_E_Modifier => Emoji,                             // rule WB14
+                    wd::WC_CR | wd::WC_LF | wd::WC_Newline => {
+                        if state == Start {
+                            if cat == wd::WC_LF {
+                                idx -= match self.get_prev_cat(idx) {
+                                    Some(pcat) if pcat == wd::WC_CR => 1,   // rule WB3
+                                    _ => 0
+                                };
+                            }
+                        } else {
+                            take_curr = false;
+                        }
+                        break;                                              // rule WB3a
+                    },
+                    _ => break                              // rule WB999
+                },
+                Zwj => match cat {                          // rule WB3c
+                    wd::WC_ZWJ => {
+                        FormatExtend(AcceptAny)
+                    }
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Letter | HLetter => match cat {
+                    wd::WC_ALetter => Letter,               // rule WB5
+                    wd::WC_Hebrew_Letter => HLetter,        // rule WB5
+                    wd::WC_Numeric => Numeric,              // rule WB10
+                    wd::WC_ExtendNumLet => ExtendNumLet,    // rule WB13b
+                    wd::WC_Double_Quote if state == HLetter => {
+                        saveidx = previdx;
+                        FormatExtend(RequireHLetter)         // rule WB7c
+                    },
+                    wd::WC_MidLetter | wd::WC_MidNumLet | wd::WC_Single_Quote => {
+                        saveidx = previdx;
+                        FormatExtend(RequireLetter)          // rule WB7
+                    },
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Numeric => match cat {
+                    wd::WC_Numeric => Numeric,              // rule WB8
+                    wd::WC_ALetter => Letter,               // rule WB9
+                    wd::WC_Hebrew_Letter => HLetter,        // rule WB9
+                    wd::WC_ExtendNumLet => ExtendNumLet,    // rule WB13b
+                    wd::WC_MidNum | wd::WC_MidNumLet | wd::WC_Single_Quote => {
+                        saveidx = previdx;
+                        FormatExtend(RequireNumeric)         // rule WB11
+                    },
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Katakana => match cat {
+                    wd::WC_Katakana => Katakana,            // rule WB13
+                    wd::WC_ExtendNumLet => ExtendNumLet,    // rule WB13b
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                ExtendNumLet => match cat {
+                    wd::WC_ExtendNumLet => ExtendNumLet,    // rule WB13a
+                    wd::WC_ALetter => Letter,               // rule WB13a
+                    wd::WC_Hebrew_Letter => HLetter,        // rule WB13a
+                    wd::WC_Numeric => Numeric,              // rule WB13a
+                    wd::WC_Katakana => Katakana,            // rule WB13a
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Regional(mut regional_state) => match cat {
+                    // rule WB13c
+                    wd::WC_Regional_Indicator => {
+                        if regional_state == RegionalState::Unknown {
+                            let count = self.string[..previdx]
+                                            .chars().rev()
+                                            .map(|c| wd::word_category(c))
+                                            .filter(|&c| ! (c == wd::WC_ZWJ || c == wd::WC_Extend || c == wd::WC_Format))
+                                            .take_while(|&c| c == wd::WC_Regional_Indicator)
+                                            .count();
+                            regional_state = if count % 2 == 0 {
+                                RegionalState::Full
+                            } else {
+                                RegionalState::Half
+                            };
+                        }
+                        if regional_state == RegionalState::Full {
+                            take_curr = false;
+                            break;
+                        } else {
+                            Regional(RegionalState::Full)
+                        }
+                    }
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                Emoji => match cat {                            // rule WB14
+                    wd::WC_E_Base | wd::WC_E_Base_GAZ => {
+                        Zwj
+                    },
+                    _ => {
+                        take_curr = false;
+                        break;
+                    }
+                },
+                FormatExtend(t) => match t {
+                    RequireNumeric if cat == wd::WC_Numeric => Numeric,          // rule WB12
+                    RequireLetter if cat == wd::WC_ALetter => Letter,            // rule WB6
+                    RequireLetter if cat == wd::WC_Hebrew_Letter => HLetter,     // rule WB6
+                    AcceptQLetter if cat == wd::WC_Hebrew_Letter => HLetter,     // rule WB7a
+                    RequireHLetter if cat == wd::WC_Hebrew_Letter => HLetter,    // rule WB7b
+                    _ => break  // backtrack will happens
+                }
+            }
+        }
+
+        if let FormatExtend(t) = state {
+            // if we required something but didn't find it, backtrack
+            if t == RequireLetter || t == RequireHLetter ||
+                t == RequireNumeric || t == AcceptNone || t == AcceptQLetter {
+                previdx = saveidx;
+                take_cat = false;
+                take_curr = false;
+            }
+        }
+
+        self.catb = if take_curr {
+            None
+        } else {
+            idx = previdx;
+            if take_cat {
+                Some(cat)
+            } else {
+                None
+            }
+        };
+
+        let retstr = &self.string[idx..];
+        self.string = &self.string[..idx];
+        Some(retstr)
+    }
+}
+
+impl<'a> UWordBounds<'a> {
+    #[inline]
+    /// View the underlying data (the part yet to be iterated) as a slice of the original string.
+    ///
+    /// ```rust
+    /// # use unicode_segmentation::UnicodeSegmentation;
+    /// let mut iter = "Hello world".split_word_bounds();
+    /// assert_eq!(iter.as_str(), "Hello world");
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), " world");
+    /// iter.next();
+    /// assert_eq!(iter.as_str(), "world");
+    /// ```
+    pub fn as_str(&self) -> &'a str {
+        self.string
+    }
+
+    #[inline]
+    fn get_next_cat(&self, idx: usize) -> Option<WordCat> {
+        use tables::word as wd;
+        let nidx = idx + self.string[idx..].chars().next().unwrap().len_utf8();
+        if nidx < self.string.len() {
+            let nch = self.string[nidx..].chars().next().unwrap();
+            Some(wd::word_category(nch))
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn get_prev_cat(&self, idx: usize) -> Option<WordCat> {
+        use tables::word as wd;
+        if idx > 0 {
+            let nch = self.string[..idx].chars().next_back().unwrap();
+            Some(wd::word_category(nch))
+        } else {
+            None
+        }
+    }
+}
+
+#[inline]
+pub fn new_word_bounds<'b>(s: &'b str) -> UWordBounds<'b> {
+    UWordBounds { string: s, cat: None, catb: None }
+}
+
+#[inline]
+pub fn new_word_bound_indices<'b>(s: &'b str) -> UWordBoundIndices<'b> {
+    UWordBoundIndices { start_offset: s.as_ptr() as usize, iter: new_word_bounds(s) }
+}
+
+#[inline]
+pub fn new_unicode_words<'b>(s: &'b str) -> UnicodeWords<'b> {
+    use super::UnicodeSegmentation;
+    use tables::util::is_alphanumeric;
+
+    fn has_alphanumeric(s: &&str) -> bool { s.chars().any(|c| is_alphanumeric(c)) }
+    let has_alphanumeric: fn(&&str) -> bool = has_alphanumeric; // coerce to fn pointer
+
+    UnicodeWords { inner: s.split_word_bounds().filter(has_alphanumeric) }
+}