From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/ucd-trie/.cargo-checksum.json | 1 + vendor/ucd-trie/Cargo.toml | 30 + vendor/ucd-trie/LICENSE-APACHE | 201 + vendor/ucd-trie/LICENSE-MIT | 21 + vendor/ucd-trie/README.md | 22 + vendor/ucd-trie/benches/bench.rs | 28 + vendor/ucd-trie/src/general_category.rs | 6297 +++++++++++++++++++++++++++++++ vendor/ucd-trie/src/lib.rs | 117 + vendor/ucd-trie/src/owned.rs | 371 ++ 9 files changed, 7088 insertions(+) create mode 100644 vendor/ucd-trie/.cargo-checksum.json create mode 100644 vendor/ucd-trie/Cargo.toml create mode 100644 vendor/ucd-trie/LICENSE-APACHE create mode 100644 vendor/ucd-trie/LICENSE-MIT create mode 100644 vendor/ucd-trie/README.md create mode 100644 vendor/ucd-trie/benches/bench.rs create mode 100644 vendor/ucd-trie/src/general_category.rs create mode 100644 vendor/ucd-trie/src/lib.rs create mode 100644 vendor/ucd-trie/src/owned.rs (limited to 'vendor/ucd-trie') diff --git a/vendor/ucd-trie/.cargo-checksum.json b/vendor/ucd-trie/.cargo-checksum.json new file mode 100644 index 000000000..756938e55 --- /dev/null +++ b/vendor/ucd-trie/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"164cfd341c21e0a60950d5c45d905093cf7275519c94eea00dfc9ed3f680445a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f","README.md":"59f7959bcf6f02efe8b325c66ea8247bd4ac6d7dd16afc585b118bd651de65e1","benches/bench.rs":"a3ca5c4d295b1611e2f79ae2295708ddd0c523d9bb1e3319ccf701832d73b9e5","src/general_category.rs":"7501e09b55f8ad0fc5c6c4f42a9d3030a8f81d1dfbe53d42e1dc17c9e24e5cac","src/lib.rs":"55c391de5921cadc39b5142d12fd603dd60b136ae0a61462546bfcf5052958f9","src/owned.rs":"b897f815685f597f3a98613d5f8196153a207a741e61bbb19f48f90c2bf594ae"},"package":"56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"} \ No newline at end of file diff --git a/vendor/ucd-trie/Cargo.toml b/vendor/ucd-trie/Cargo.toml new file mode 100644 index 000000000..491d8a8c4 --- /dev/null +++ b/vendor/ucd-trie/Cargo.toml @@ -0,0 +1,30 @@ +# 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] +edition = "2018" +name = "ucd-trie" +version = "0.1.3" +authors = ["Andrew Gallant "] +description = "A trie for storing Unicode codepoint sets and maps.\n" +homepage = "https://github.com/BurntSushi/ucd-generate" +documentation = "https://docs.rs/ucd-trie" +readme = "README.md" +keywords = ["unicode", "database", "character", "codepoint", "trie"] +license = "MIT/Apache-2.0" +repository = "https://github.com/BurntSushi/ucd-generate" +[dev-dependencies.lazy_static] +version = "1" + +[features] +default = ["std"] +std = [] diff --git a/vendor/ucd-trie/LICENSE-APACHE b/vendor/ucd-trie/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/vendor/ucd-trie/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/vendor/ucd-trie/LICENSE-MIT b/vendor/ucd-trie/LICENSE-MIT new file mode 100644 index 000000000..3b0a5dc09 --- /dev/null +++ b/vendor/ucd-trie/LICENSE-MIT @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Andrew Gallant + +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/vendor/ucd-trie/README.md b/vendor/ucd-trie/README.md new file mode 100644 index 000000000..b70fbfca6 --- /dev/null +++ b/vendor/ucd-trie/README.md @@ -0,0 +1,22 @@ +ucd-trie +======== +A library that provides compressed trie sets specifically tailored toward +representing boolean Unicode character properties. + +[![Linux build status](https://api.travis-ci.org/BurntSushi/ucd-generate.png)](https://travis-ci.org/BurntSushi/ucd-generate) +[![](http://meritbadge.herokuapp.com/ucd-generate)](https://crates.io/crates/ucd-trie) + + +### Documentation + +https://docs.rs/ucd-trie + + +### License + +This project is 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. diff --git a/vendor/ucd-trie/benches/bench.rs b/vendor/ucd-trie/benches/bench.rs new file mode 100644 index 000000000..53c04b9d0 --- /dev/null +++ b/vendor/ucd-trie/benches/bench.rs @@ -0,0 +1,28 @@ +#![feature(test)] + +#[macro_use] +extern crate lazy_static; +extern crate test; + +use ucd_trie::TrieSetOwned; + +#[bench] +fn bench_trie_set(b: &mut test::Bencher) { + const CHARS: &'static [char] = &['a', 'β', '☃', '😼']; + // const CHARS: &'static [char] = &['a']; + lazy_static! { + static ref SET: TrieSetOwned = + TrieSetOwned::from_scalars(CHARS).unwrap(); + } + + let set = &*SET; + let mut i = 0; + b.iter(|| { + let c = CHARS[i]; + i = (i + 1) % CHARS.len(); + + for _ in 0..10000 { + assert!(set.contains_char(c)); + } + }); +} diff --git a/vendor/ucd-trie/src/general_category.rs b/vendor/ucd-trie/src/general_category.rs new file mode 100644 index 000000000..63383a9d7 --- /dev/null +++ b/vendor/ucd-trie/src/general_category.rs @@ -0,0 +1,6297 @@ +// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY: +// +// ucd-generate general-category ./ucd-13.0.0 +// +// ucd-generate 0.2.6 is available on crates.io. + +pub const BY_NAME: &'static [(&'static str, &'static [(u32, u32)])] = &[ + ("Cased_Letter", CASED_LETTER), + ("Close_Punctuation", CLOSE_PUNCTUATION), + ("Connector_Punctuation", CONNECTOR_PUNCTUATION), + ("Control", CONTROL), + ("Currency_Symbol", CURRENCY_SYMBOL), + ("Dash_Punctuation", DASH_PUNCTUATION), + ("Decimal_Number", DECIMAL_NUMBER), + ("Enclosing_Mark", ENCLOSING_MARK), + ("Final_Punctuation", FINAL_PUNCTUATION), + ("Format", FORMAT), + ("Initial_Punctuation", INITIAL_PUNCTUATION), + ("Letter", LETTER), + ("Letter_Number", LETTER_NUMBER), + ("Line_Separator", LINE_SEPARATOR), + ("Lowercase_Letter", LOWERCASE_LETTER), + ("Mark", MARK), + ("Math_Symbol", MATH_SYMBOL), + ("Modifier_Letter", MODIFIER_LETTER), + ("Modifier_Symbol", MODIFIER_SYMBOL), + ("Nonspacing_Mark", NONSPACING_MARK), + ("Number", NUMBER), + ("Open_Punctuation", OPEN_PUNCTUATION), + ("Other", OTHER), + ("Other_Letter", OTHER_LETTER), + ("Other_Number", OTHER_NUMBER), + ("Other_Punctuation", OTHER_PUNCTUATION), + ("Other_Symbol", OTHER_SYMBOL), + ("Paragraph_Separator", PARAGRAPH_SEPARATOR), + ("Private_Use", PRIVATE_USE), + ("Punctuation", PUNCTUATION), + ("Separator", SEPARATOR), + ("Space_Separator", SPACE_SEPARATOR), + ("Spacing_Mark", SPACING_MARK), + ("Surrogate", SURROGATE), + ("Symbol", SYMBOL), + ("Titlecase_Letter", TITLECASE_LETTER), + ("Unassigned", UNASSIGNED), + ("Uppercase_Letter", UPPERCASE_LETTER), +]; + +pub const CASED_LETTER: &'static [(u32, u32)] = &[ + (65, 90), + (97, 122), + (181, 181), + (192, 214), + (216, 246), + (248, 442), + (444, 447), + (452, 659), + (661, 687), + (880, 883), + (886, 887), + (891, 893), + (895, 895), + (902, 902), + (904, 906), + (908, 908), + (910, 929), + (931, 1013), + (1015, 1153), + (1162, 1327), + (1329, 1366), + (1376, 1416), + (4256, 4293), + (4295, 4295), + (4301, 4301), + (4304, 4346), + (4349, 4351), + (5024, 5109), + (5112, 5117), + (7296, 7304), + (7312, 7354), + (7357, 7359), + (7424, 7467), + (7531, 7543), + (7545, 7578), + (7680, 7957), + (7960, 7965), + (7968, 8005), + (8008, 8013), + (8016, 8023), + (8025, 8025), + (8027, 8027), + (8029, 8029), + (8031, 8061), + (8064, 8116), + (8118, 8124), + (8126, 8126), + (8130, 8132), + (8134, 8140), + (8144, 8147), + (8150, 8155), + (8160, 8172), + (8178, 8180), + (8182, 8188), + (8450, 8450), + (8455, 8455), + (8458, 8467), + (8469, 8469), + (8473, 8477), + (8484, 8484), + (8486, 8486), + (8488, 8488), + (8490, 8493), + (8495, 8500), + (8505, 8505), + (8508, 8511), + (8517, 8521), + (8526, 8526), + (8579, 8580), + (11264, 11310), + (11312, 11358), + (11360, 11387), + (11390, 11492), + (11499, 11502), + (11506, 11507), + (11520, 11557), + (11559, 11559), + (11565, 11565), + (42560, 42605), + (42624, 42651), + (42786, 42863), + (42865, 42887), + (42891, 42894), + (42896, 42943), + (42946, 42954), + (42997, 42998), + (43002, 43002), + (43824, 43866), + (43872, 43880), + (43888, 43967), + (64256, 64262), + (64275, 64279), + (65313, 65338), + (65345, 65370), + (66560, 66639), + (66736, 66771), + (66776, 66811), + (68736, 68786), + (68800, 68850), + (71840, 71903), + (93760, 93823), + (119808, 119892), + (119894, 119964), + (119966, 119967), + (119970, 119970), + (119973, 119974), + (119977, 119980), + (119982, 119993), + (119995, 119995), + (119997, 120003), + (120005, 120069), + (120071, 120074), + (120077, 120084), + (120086, 120092), + (120094, 120121), + (120123, 120126), + (120128, 120132), + (120134, 120134), + (120138, 120144), + (120146, 120485), + (120488, 120512), + (120514, 120538), + (120540, 120570), + (120572, 120596), + (120598, 120628), + (120630, 120654), + (120656, 120686), + (120688, 120712), + (120714, 120744), + (120746, 120770), + (120772, 120779), + (125184, 125251), +]; + +pub const CLOSE_PUNCTUATION: &'static [(u32, u32)] = &[ + (41, 41), + (93, 93), + (125, 125), + (3899, 3899), + (3901, 3901), + (5788, 5788), + (8262, 8262), + (8318, 8318), + (8334, 8334), + (8969, 8969), + (8971, 8971), + (9002, 9002), + (10089, 10089), + (10091, 10091), + (10093, 10093), + (10095, 10095), + (10097, 10097), + (10099, 10099), + (10101, 10101), + (10182, 10182), + (10215, 10215), + (10217, 10217), + (10219, 10219), + (10221, 10221), + (10223, 10223), + (10628, 10628), + (10630, 10630), + (10632, 10632), + (10634, 10634), + (10636, 10636), + (10638, 10638), + (10640, 10640), + (10642, 10642), + (10644, 10644), + (10646, 10646), + (10648, 10648), + (10713, 10713), + (10715, 10715), + (10749, 10749), + (11811, 11811), + (11813, 11813), + (11815, 11815), + (11817, 11817), + (12297, 12297), + (12299, 12299), + (12301, 12301), + (12303, 12303), + (12305, 12305), + (12309, 12309), + (12311, 12311), + (12313, 12313), + (12315, 12315), + (12318, 12319), + (64830, 64830), + (65048, 65048), + (65078, 65078), + (65080, 65080), + (65082, 65082), + (65084, 65084), + (65086, 65086), + (65088, 65088), + (65090, 65090), + (65092, 65092), + (65096, 65096), + (65114, 65114), + (65116, 65116), + (65118, 65118), + (65289, 65289), + (65341, 65341), + (65373, 65373), + (65376, 65376), + (65379, 65379), +]; + +pub const CONNECTOR_PUNCTUATION: &'static [(u32, u32)] = &[ + (95, 95), + (8255, 8256), + (8276, 8276), + (65075, 65076), + (65101, 65103), + (65343, 65343), +]; + +pub const CONTROL: &'static [(u32, u32)] = &[(0, 31), (127, 159)]; + +pub const CURRENCY_SYMBOL: &'static [(u32, u32)] = &[ + (36, 36), + (162, 165), + (1423, 1423), + (1547, 1547), + (2046, 2047), + (2546, 2547), + (2555, 2555), + (2801, 2801), + (3065, 3065), + (3647, 3647), + (6107, 6107), + (8352, 8383), + (43064, 43064), + (65020, 65020), + (65129, 65129), + (65284, 65284), + (65504, 65505), + (65509, 65510), + (73693, 73696), + (123647, 123647), + (126128, 126128), +]; + +pub const DASH_PUNCTUATION: &'static [(u32, u32)] = &[ + (45, 45), + (1418, 1418), + (1470, 1470), + (5120, 5120), + (6150, 6150), + (8208, 8213), + (11799, 11799), + (11802, 11802), + (11834, 11835), + (11840, 11840), + (12316, 12316), + (12336, 12336), + (12448, 12448), + (65073, 65074), + (65112, 65112), + (65123, 65123), + (65293, 65293), + (69293, 69293), +]; + +pub const DECIMAL_NUMBER: &'static [(u32, u32)] = &[ + (48, 57), + (1632, 1641), + (1776, 1785), + (1984, 1993), + (2406, 2415), + (2534, 2543), + (2662, 2671), + (2790, 2799), + (2918, 2927), + (3046, 3055), + (3174, 3183), + (3302, 3311), + (3430, 3439), + (3558, 3567), + (3664, 3673), + (3792, 3801), + (3872, 3881), + (4160, 4169), + (4240, 4249), + (6112, 6121), + (6160, 6169), + (6470, 6479), + (6608, 6617), + (6784, 6793), + (6800, 6809), + (6992, 7001), + (7088, 7097), + (7232, 7241), + (7248, 7257), + (42528, 42537), + (43216, 43225), + (43264, 43273), + (43472, 43481), + (43504, 43513), + (43600, 43609), + (44016, 44025), + (65296, 65305), + (66720, 66729), + (68912, 68921), + (69734, 69743), + (69872, 69881), + (69942, 69951), + (70096, 70105), + (70384, 70393), + (70736, 70745), + (70864, 70873), + (71248, 71257), + (71360, 71369), + (71472, 71481), + (71904, 71913), + (72016, 72025), + (72784, 72793), + (73040, 73049), + (73120, 73129), + (92768, 92777), + (93008, 93017), + (120782, 120831), + (123200, 123209), + (123632, 123641), + (125264, 125273), + (130032, 130041), +]; + +pub const ENCLOSING_MARK: &'static [(u32, u32)] = + &[(1160, 1161), (6846, 6846), (8413, 8416), (8418, 8420), (42608, 42610)]; + +pub const FINAL_PUNCTUATION: &'static [(u32, u32)] = &[ + (187, 187), + (8217, 8217), + (8221, 8221), + (8250, 8250), + (11779, 11779), + (11781, 11781), + (11786, 11786), + (11789, 11789), + (11805, 11805), + (11809, 11809), +]; + +pub const FORMAT: &'static [(u32, u32)] = &[ + (173, 173), + (1536, 1541), + (1564, 1564), + (1757, 1757), + (1807, 1807), + (2274, 2274), + (6158, 6158), + (8203, 8207), + (8234, 8238), + (8288, 8292), + (8294, 8303), + (65279, 65279), + (65529, 65531), + (69821, 69821), + (69837, 69837), + (78896, 78904), + (113824, 113827), + (119155, 119162), + (917505, 917505), + (917536, 917631), +]; + +pub const INITIAL_PUNCTUATION: &'static [(u32, u32)] = &[ + (171, 171), + (8216, 8216), + (8219, 8220), + (8223, 8223), + (8249, 8249), + (11778, 11778), + (11780, 11780), + (11785, 11785), + (11788, 11788), + (11804, 11804), + (11808, 11808), +]; + +pub const LETTER: &'static [(u32, u32)] = &[ + (65, 90), + (97, 122), + (170, 170), + (181, 181), + (186, 186), + (192, 214), + (216, 246), + (248, 705), + (710, 721), + (736, 740), + (748, 748), + (750, 750), + (880, 884), + (886, 887), + (890, 893), + (895, 895), + (902, 902), + (904, 906), + (908, 908), + (910, 929), + (931, 1013), + (1015, 1153), + (1162, 1327), + (1329, 1366), + (1369, 1369), + (1376, 1416), + (1488, 1514), + (1519, 1522), + (1568, 1610), + (1646, 1647), + (1649, 1747), + (1749, 1749), + (1765, 1766), + (1774, 1775), + (1786, 1788), + (1791, 1791), + (1808, 1808), + (1810, 1839), + (1869, 1957), + (1969, 1969), + (1994, 2026), + (2036, 2037), + (2042, 2042), + (2048, 2069), + (2074, 2074), + (2084, 2084), + (2088, 2088), + (2112, 2136), + (2144, 2154), + (2208, 2228), + (2230, 2247), + (2308, 2361), + (2365, 2365), + (2384, 2384), + (2392, 2401), + (2417, 2432), + (2437, 2444), + (2447, 2448), + (2451, 2472), + (2474, 2480), + (2482, 2482), + (2486, 2489), + (2493, 2493), + (2510, 2510), + (2524, 2525), + (2527, 2529), + (2544, 2545), + (2556, 2556), + (2565, 2570), + (2575, 2576), + (2579, 2600), + (2602, 2608), + (2610, 2611), + (2613, 2614), + (2616, 2617), + (2649, 2652), + (2654, 2654), + (2674, 2676), + (2693, 2701), + (2703, 2705), + (2707, 2728), + (2730, 2736), + (2738, 2739), + (2741, 2745), + (2749, 2749), + (2768, 2768), + (2784, 2785), + (2809, 2809), + (2821, 2828), + (2831, 2832), + (2835, 2856), + (2858, 2864), + (2866, 2867), + (2869, 2873), + (2877, 2877), + (2908, 2909), + (2911, 2913), + (2929, 2929), + (2947, 2947), + (2949, 2954), + (2958, 2960), + (2962, 2965), + (2969, 2970), + (2972, 2972), + (2974, 2975), + (2979, 2980), + (2984, 2986), + (2990, 3001), + (3024, 3024), + (3077, 3084), + (3086, 3088), + (3090, 3112), + (3114, 3129), + (3133, 3133), + (3160, 3162), + (3168, 3169), + (3200, 3200), + (3205, 3212), + (3214, 3216), + (3218, 3240), + (3242, 3251), + (3253, 3257), + (3261, 3261), + (3294, 3294), + (3296, 3297), + (3313, 3314), + (3332, 3340), + (3342, 3344), + (3346, 3386), + (3389, 3389), + (3406, 3406), + (3412, 3414), + (3423, 3425), + (3450, 3455), + (3461, 3478), + (3482, 3505), + (3507, 3515), + (3517, 3517), + (3520, 3526), + (3585, 3632), + (3634, 3635), + (3648, 3654), + (3713, 3714), + (3716, 3716), + (3718, 3722), + (3724, 3747), + (3749, 3749), + (3751, 3760), + (3762, 3763), + (3773, 3773), + (3776, 3780), + (3782, 3782), + (3804, 3807), + (3840, 3840), + (3904, 3911), + (3913, 3948), + (3976, 3980), + (4096, 4138), + (4159, 4159), + (4176, 4181), + (4186, 4189), + (4193, 4193), + (4197, 4198), + (4206, 4208), + (4213, 4225), + (4238, 4238), + (4256, 4293), + (4295, 4295), + (4301, 4301), + (4304, 4346), + (4348, 4680), + (4682, 4685), + (4688, 4694), + (4696, 4696), + (4698, 4701), + (4704, 4744), + (4746, 4749), + (4752, 4784), + (4786, 4789), + (4792, 4798), + (4800, 4800), + (4802, 4805), + (4808, 4822), + (4824, 4880), + (4882, 4885), + (4888, 4954), + (4992, 5007), + (5024, 5109), + (5112, 5117), + (5121, 5740), + (5743, 5759), + (5761, 5786), + (5792, 5866), + (5873, 5880), + (5888, 5900), + (5902, 5905), + (5920, 5937), + (5952, 5969), + (5984, 5996), + (5998, 6000), + (6016, 6067), + (6103, 6103), + (6108, 6108), + (6176, 6264), + (6272, 6276), + (6279, 6312), + (6314, 6314), + (6320, 6389), + (6400, 6430), + (6480, 6509), + (6512, 6516), + (6528, 6571), + (6576, 6601), + (6656, 6678), + (6688, 6740), + (6823, 6823), + (6917, 6963), + (6981, 6987), + (7043, 7072), + (7086, 7087), + (7098, 7141), + (7168, 7203), + (7245, 7247), + (7258, 7293), + (7296, 7304), + (7312, 7354), + (7357, 7359), + (7401, 7404), + (7406, 7411), + (7413, 7414), + (7418, 7418), + (7424, 7615), + (7680, 7957), + (7960, 7965), + (7968, 8005), + (8008, 8013), + (8016, 8023), + (8025, 8025), + (8027, 8027), + (8029, 8029), + (8031, 8061), + (8064, 8116), + (8118, 8124), + (8126, 8126), + (8130, 8132), + (8134, 8140), + (8144, 8147), + (8150, 8155), + (8160, 8172), + (8178, 8180), + (8182, 8188), + (8305, 8305), + (8319, 8319), + (8336, 8348), + (8450, 8450), + (8455, 8455), + (8458, 8467), + (8469, 8469), + (8473, 8477), + (8484, 8484), + (8486, 8486), + (8488, 8488), + (8490, 8493), + (8495, 8505), + (8508, 8511), + (8517, 8521), + (8526, 8526), + (8579, 8580), + (11264, 11310), + (11312, 11358), + (11360, 11492), + (11499, 11502), + (11506, 11507), + (11520, 11557), + (11559, 11559), + (11565, 11565), + (11568, 11623), + (11631, 11631), + (11648, 11670), + (11680, 11686), + (11688, 11694), + (11696, 11702), + (11704, 11710), + (11712, 11718), + (11720, 11726), + (11728, 11734), + (11736, 11742), + (11823, 11823), + (12293, 12294), + (12337, 12341), + (12347, 12348), + (12353, 12438), + (12445, 12447), + (12449, 12538), + (12540, 12543), + (12549, 12591), + (12593, 12686), + (12704, 12735), + (12784, 12799), + (13312, 19903), + (19968, 40956), + (40960, 42124), + (42192, 42237), + (42240, 42508), + (42512, 42527), + (42538, 42539), + (42560, 42606), + (42623, 42653), + (42656, 42725), + (42775, 42783), + (42786, 42888), + (42891, 42943), + (42946, 42954), + (42997, 43009), + (43011, 43013), + (43015, 43018), + (43020, 43042), + (43072, 43123), + (43138, 43187), + (43250, 43255), + (43259, 43259), + (43261, 43262), + (43274, 43301), + (43312, 43334), + (43360, 43388), + (43396, 43442), + (43471, 43471), + (43488, 43492), + (43494, 43503), + (43514, 43518), + (43520, 43560), + (43584, 43586), + (43588, 43595), + (43616, 43638), + (43642, 43642), + (43646, 43695), + (43697, 43697), + (43701, 43702), + (43705, 43709), + (43712, 43712), + (43714, 43714), + (43739, 43741), + (43744, 43754), + (43762, 43764), + (43777, 43782), + (43785, 43790), + (43793, 43798), + (43808, 43814), + (43816, 43822), + (43824, 43866), + (43868, 43881), + (43888, 44002), + (44032, 55203), + (55216, 55238), + (55243, 55291), + (63744, 64109), + (64112, 64217), + (64256, 64262), + (64275, 64279), + (64285, 64285), + (64287, 64296), + (64298, 64310), + (64312, 64316), + (64318, 64318), + (64320, 64321), + (64323, 64324), + (64326, 64433), + (64467, 64829), + (64848, 64911), + (64914, 64967), + (65008, 65019), + (65136, 65140), + (65142, 65276), + (65313, 65338), + (65345, 65370), + (65382, 65470), + (65474, 65479), + (65482, 65487), + (65490, 65495), + (65498, 65500), + (65536, 65547), + (65549, 65574), + (65576, 65594), + (65596, 65597), + (65599, 65613), + (65616, 65629), + (65664, 65786), + (66176, 66204), + (66208, 66256), + (66304, 66335), + (66349, 66368), + (66370, 66377), + (66384, 66421), + (66432, 66461), + (66464, 66499), + (66504, 66511), + (66560, 66717), + (66736, 66771), + (66776, 66811), + (66816, 66855), + (66864, 66915), + (67072, 67382), + (67392, 67413), + (67424, 67431), + (67584, 67589), + (67592, 67592), + (67594, 67637), + (67639, 67640), + (67644, 67644), + (67647, 67669), + (67680, 67702), + (67712, 67742), + (67808, 67826), + (67828, 67829), + (67840, 67861), + (67872, 67897), + (67968, 68023), + (68030, 68031), + (68096, 68096), + (68112, 68115), + (68117, 68119), + (68121, 68149), + (68192, 68220), + (68224, 68252), + (68288, 68295), + (68297, 68324), + (68352, 68405), + (68416, 68437), + (68448, 68466), + (68480, 68497), + (68608, 68680), + (68736, 68786), + (68800, 68850), + (68864, 68899), + (69248, 69289), + (69296, 69297), + (69376, 69404), + (69415, 69415), + (69424, 69445), + (69552, 69572), + (69600, 69622), + (69635, 69687), + (69763, 69807), + (69840, 69864), + (69891, 69926), + (69956, 69956), + (69959, 69959), + (69968, 70002), + (70006, 70006), + (70019, 70066), + (70081, 70084), + (70106, 70106), + (70108, 70108), + (70144, 70161), + (70163, 70187), + (70272, 70278), + (70280, 70280), + (70282, 70285), + (70287, 70301), + (70303, 70312), + (70320, 70366), + (70405, 70412), + (70415, 70416), + (70419, 70440), + (70442, 70448), + (70450, 70451), + (70453, 70457), + (70461, 70461), + (70480, 70480), + (70493, 70497), + (70656, 70708), + (70727, 70730), + (70751, 70753), + (70784, 70831), + (70852, 70853), + (70855, 70855), + (71040, 71086), + (71128, 71131), + (71168, 71215), + (71236, 71236), + (71296, 71338), + (71352, 71352), + (71424, 71450), + (71680, 71723), + (71840, 71903), + (71935, 71942), + (71945, 71945), + (71948, 71955), + (71957, 71958), + (71960, 71983), + (71999, 71999), + (72001, 72001), + (72096, 72103), + (72106, 72144), + (72161, 72161), + (72163, 72163), + (72192, 72192), + (72203, 72242), + (72250, 72250), + (72272, 72272), + (72284, 72329), + (72349, 72349), + (72384, 72440), + (72704, 72712), + (72714, 72750), + (72768, 72768), + (72818, 72847), + (72960, 72966), + (72968, 72969), + (72971, 73008), + (73030, 73030), + (73056, 73061), + (73063, 73064), + (73066, 73097), + (73112, 73112), + (73440, 73458), + (73648, 73648), + (73728, 74649), + (74880, 75075), + (77824, 78894), + (82944, 83526), + (92160, 92728), + (92736, 92766), + (92880, 92909), + (92928, 92975), + (92992, 92995), + (93027, 93047), + (93053, 93071), + (93760, 93823), + (93952, 94026), + (94032, 94032), + (94099, 94111), + (94176, 94177), + (94179, 94179), + (94208, 100343), + (100352, 101589), + (101632, 101640), + (110592, 110878), + (110928, 110930), + (110948, 110951), + (110960, 111355), + (113664, 113770), + (113776, 113788), + (113792, 113800), + (113808, 113817), + (119808, 119892), + (119894, 119964), + (119966, 119967), + (119970, 119970), + (119973, 119974), + (119977, 119980), + (119982, 119993), + (119995, 119995), + (119997, 120003), + (120005, 120069), + (120071, 120074), + (120077, 120084), + (120086, 120092), + (120094, 120121), + (120123, 120126), + (120128, 120132), + (120134, 120134), + (120138, 120144), + (120146, 120485), + (120488, 120512), + (120514, 120538), + (120540, 120570), + (120572, 120596), + (120598, 120628), + (120630, 120654), + (120656, 120686), + (120688, 120712), + (120714, 120744), + (120746, 120770), + (120772, 120779), + (123136, 123180), + (123191, 123197), + (123214, 123214), + (123584, 123627), + (124928, 125124), + (125184, 125251), + (125259, 125259), + (126464, 126467), + (126469, 126495), + (126497, 126498), + (126500, 126500), + (126503, 126503), + (126505, 126514), + (126516, 126519), + (126521, 126521), + (126523, 126523), + (126530, 126530), + (126535, 126535), + (126537, 126537), + (126539, 126539), + (126541, 126543), + (126545, 126546), + (126548, 126548), + (126551, 126551), + (126553, 126553), + (126555, 126555), + (126557, 126557), + (126559, 126559), + (126561, 126562), + (126564, 126564), + (126567, 126570), + (126572, 126578), + (126580, 126583), + (126585, 126588), + (126590, 126590), + (126592, 126601), + (126603, 126619), + (126625, 126627), + (126629, 126633), + (126635, 126651), + (131072, 173789), + (173824, 177972), + (177984, 178205), + (178208, 183969), + (183984, 191456), + (194560, 195101), + (196608, 201546), +]; + +pub const LETTER_NUMBER: &'static [(u32, u32)] = &[ + (5870, 5872), + (8544, 8578), + (8581, 8584), + (12295, 12295), + (12321, 12329), + (12344, 12346), + (42726, 42735), + (65856, 65908), + (66369, 66369), + (66378, 66378), + (66513, 66517), + (74752, 74862), +]; + +pub const LINE_SEPARATOR: &'static [(u32, u32)] = &[(8232, 8232)]; + +pub const LOWERCASE_LETTER: &'static [(u32, u32)] = &[ + (97, 122), + (181, 181), + (223, 246), + (248, 255), + (257, 257), + (259, 259), + (261, 261), + (263, 263), + (265, 265), + (267, 267), + (269, 269), + (271, 271), + (273, 273), + (275, 275), + (277, 277), + (279, 279), + (281, 281), + (283, 283), + (285, 285), + (287, 287), + (289, 289), + (291, 291), + (293, 293), + (295, 295), + (297, 297), + (299, 299), + (301, 301), + (303, 303), + (305, 305), + (307, 307), + (309, 309), + (311, 312), + (314, 314), + (316, 316), + (318, 318), + (320, 320), + (322, 322), + (324, 324), + (326, 326), + (328, 329), + (331, 331), + (333, 333), + (335, 335), + (337, 337), + (339, 339), + (341, 341), + (343, 343), + (345, 345), + (347, 347), + (349, 349), + (351, 351), + (353, 353), + (355, 355), + (357, 357), + (359, 359), + (361, 361), + (363, 363), + (365, 365), + (367, 367), + (369, 369), + (371, 371), + (373, 373), + (375, 375), + (378, 378), + (380, 380), + (382, 384), + (387, 387), + (389, 389), + (392, 392), + (396, 397), + (402, 402), + (405, 405), + (409, 411), + (414, 414), + (417, 417), + (419, 419), + (421, 421), + (424, 424), + (426, 427), + (429, 429), + (432, 432), + (436, 436), + (438, 438), + (441, 442), + (445, 447), + (454, 454), + (457, 457), + (460, 460), + (462, 462), + (464, 464), + (466, 466), + (468, 468), + (470, 470), + (472, 472), + (474, 474), + (476, 477), + (479, 479), + (481, 481), + (483, 483), + (485, 485), + (487, 487), + (489, 489), + (491, 491), + (493, 493), + (495, 496), + (499, 499), + (501, 501), + (505, 505), + (507, 507), + (509, 509), + (511, 511), + (513, 513), + (515, 515), + (517, 517), + (519, 519), + (521, 521), + (523, 523), + (525, 525), + (527, 527), + (529, 529), + (531, 531), + (533, 533), + (535, 535), + (537, 537), + (539, 539), + (541, 541), + (543, 543), + (545, 545), + (547, 547), + (549, 549), + (551, 551), + (553, 553), + (555, 555), + (557, 557), + (559, 559), + (561, 561), + (563, 569), + (572, 572), + (575, 576), + (578, 578), + (583, 583), + (585, 585), + (587, 587), + (589, 589), + (591, 659), + (661, 687), + (881, 881), + (883, 883), + (887, 887), + (891, 893), + (912, 912), + (940, 974), + (976, 977), + (981, 983), + (985, 985), + (987, 987), + (989, 989), + (991, 991), + (993, 993), + (995, 995), + (997, 997), + (999, 999), + (1001, 1001), + (1003, 1003), + (1005, 1005), + (1007, 1011), + (1013, 1013), + (1016, 1016), + (1019, 1020), + (1072, 1119), + (1121, 1121), + (1123, 1123), + (1125, 1125), + (1127, 1127), + (1129, 1129), + (1131, 1131), + (1133, 1133), + (1135, 1135), + (1137, 1137), + (1139, 1139), + (1141, 1141), + (1143, 1143), + (1145, 1145), + (1147, 1147), + (1149, 1149), + (1151, 1151), + (1153, 1153), + (1163, 1163), + (1165, 1165), + (1167, 1167), + (1169, 1169), + (1171, 1171), + (1173, 1173), + (1175, 1175), + (1177, 1177), + (1179, 1179), + (1181, 1181), + (1183, 1183), + (1185, 1185), + (1187, 1187), + (1189, 1189), + (1191, 1191), + (1193, 1193), + (1195, 1195), + (1197, 1197), + (1199, 1199), + (1201, 1201), + (1203, 1203), + (1205, 1205), + (1207, 1207), + (1209, 1209), + (1211, 1211), + (1213, 1213), + (1215, 1215), + (1218, 1218), + (1220, 1220), + (1222, 1222), + (1224, 1224), + (1226, 1226), + (1228, 1228), + (1230, 1231), + (1233, 1233), + (1235, 1235), + (1237, 1237), + (1239, 1239), + (1241, 1241), + (1243, 1243), + (1245, 1245), + (1247, 1247), + (1249, 1249), + (1251, 1251), + (1253, 1253), + (1255, 1255), + (1257, 1257), + (1259, 1259), + (1261, 1261), + (1263, 1263), + (1265, 1265), + (1267, 1267), + (1269, 1269), + (1271, 1271), + (1273, 1273), + (1275, 1275), + (1277, 1277), + (1279, 1279), + (1281, 1281), + (1283, 1283), + (1285, 1285), + (1287, 1287), + (1289, 1289), + (1291, 1291), + (1293, 1293), + (1295, 1295), + (1297, 1297), + (1299, 1299), + (1301, 1301), + (1303, 1303), + (1305, 1305), + (1307, 1307), + (1309, 1309), + (1311, 1311), + (1313, 1313), + (1315, 1315), + (1317, 1317), + (1319, 1319), + (1321, 1321), + (1323, 1323), + (1325, 1325), + (1327, 1327), + (1376, 1416), + (4304, 4346), + (4349, 4351), + (5112, 5117), + (7296, 7304), + (7424, 7467), + (7531, 7543), + (7545, 7578), + (7681, 7681), + (7683, 7683), + (7685, 7685), + (7687, 7687), + (7689, 7689), + (7691, 7691), + (7693, 7693), + (7695, 7695), + (7697, 7697), + (7699, 7699), + (7701, 7701), + (7703, 7703), + (7705, 7705), + (7707, 7707), + (7709, 7709), + (7711, 7711), + (7713, 7713), + (7715, 7715), + (7717, 7717), + (7719, 7719), + (7721, 7721), + (7723, 7723), + (7725, 7725), + (7727, 7727), + (7729, 7729), + (7731, 7731), + (7733, 7733), + (7735, 7735), + (7737, 7737), + (7739, 7739), + (7741, 7741), + (7743, 7743), + (7745, 7745), + (7747, 7747), + (7749, 7749), + (7751, 7751), + (7753, 7753), + (7755, 7755), + (7757, 7757), + (7759, 7759), + (7761, 7761), + (7763, 7763), + (7765, 7765), + (7767, 7767), + (7769, 7769), + (7771, 7771), + (7773, 7773), + (7775, 7775), + (7777, 7777), + (7779, 7779), + (7781, 7781), + (7783, 7783), + (7785, 7785), + (7787, 7787), + (7789, 7789), + (7791, 7791), + (7793, 7793), + (7795, 7795), + (7797, 7797), + (7799, 7799), + (7801, 7801), + (7803, 7803), + (7805, 7805), + (7807, 7807), + (7809, 7809), + (7811, 7811), + (7813, 7813), + (7815, 7815), + (7817, 7817), + (7819, 7819), + (7821, 7821), + (7823, 7823), + (7825, 7825), + (7827, 7827), + (7829, 7837), + (7839, 7839), + (7841, 7841), + (7843, 7843), + (7845, 7845), + (7847, 7847), + (7849, 7849), + (7851, 7851), + (7853, 7853), + (7855, 7855), + (7857, 7857), + (7859, 7859), + (7861, 7861), + (7863, 7863), + (7865, 7865), + (7867, 7867), + (7869, 7869), + (7871, 7871), + (7873, 7873), + (7875, 7875), + (7877, 7877), + (7879, 7879), + (7881, 7881), + (7883, 7883), + (7885, 7885), + (7887, 7887), + (7889, 7889), + (7891, 7891), + (7893, 7893), + (7895, 7895), + (7897, 7897), + (7899, 7899), + (7901, 7901), + (7903, 7903), + (7905, 7905), + (7907, 7907), + (7909, 7909), + (7911, 7911), + (7913, 7913), + (7915, 7915), + (7917, 7917), + (7919, 7919), + (7921, 7921), + (7923, 7923), + (7925, 7925), + (7927, 7927), + (7929, 7929), + (7931, 7931), + (7933, 7933), + (7935, 7943), + (7952, 7957), + (7968, 7975), + (7984, 7991), + (8000, 8005), + (8016, 8023), + (8032, 8039), + (8048, 8061), + (8064, 8071), + (8080, 8087), + (8096, 8103), + (8112, 8116), + (8118, 8119), + (8126, 8126), + (8130, 8132), + (8134, 8135), + (8144, 8147), + (8150, 8151), + (8160, 8167), + (8178, 8180), + (8182, 8183), + (8458, 8458), + (8462, 8463), + (8467, 8467), + (8495, 8495), + (8500, 8500), + (8505, 8505), + (8508, 8509), + (8518, 8521), + (8526, 8526), + (8580, 8580), + (11312, 11358), + (11361, 11361), + (11365, 11366), + (11368, 11368), + (11370, 11370), + (11372, 11372), + (11377, 11377), + (11379, 11380), + (11382, 11387), + (11393, 11393), + (11395, 11395), + (11397, 11397), + (11399, 11399), + (11401, 11401), + (11403, 11403), + (11405, 11405), + (11407, 11407), + (11409, 11409), + (11411, 11411), + (11413, 11413), + (11415, 11415), + (11417, 11417), + (11419, 11419), + (11421, 11421), + (11423, 11423), + (11425, 11425), + (11427, 11427), + (11429, 11429), + (11431, 11431), + (11433, 11433), + (11435, 11435), + (11437, 11437), + (11439, 11439), + (11441, 11441), + (11443, 11443), + (11445, 11445), + (11447, 11447), + (11449, 11449), + (11451, 11451), + (11453, 11453), + (11455, 11455), + (11457, 11457), + (11459, 11459), + (11461, 11461), + (11463, 11463), + (11465, 11465), + (11467, 11467), + (11469, 11469), + (11471, 11471), + (11473, 11473), + (11475, 11475), + (11477, 11477), + (11479, 11479), + (11481, 11481), + (11483, 11483), + (11485, 11485), + (11487, 11487), + (11489, 11489), + (11491, 11492), + (11500, 11500), + (11502, 11502), + (11507, 11507), + (11520, 11557), + (11559, 11559), + (11565, 11565), + (42561, 42561), + (42563, 42563), + (42565, 42565), + (42567, 42567), + (42569, 42569), + (42571, 42571), + (42573, 42573), + (42575, 42575), + (42577, 42577), + (42579, 42579), + (42581, 42581), + (42583, 42583), + (42585, 42585), + (42587, 42587), + (42589, 42589), + (42591, 42591), + (42593, 42593), + (42595, 42595), + (42597, 42597), + (42599, 42599), + (42601, 42601), + (42603, 42603), + (42605, 42605), + (42625, 42625), + (42627, 42627), + (42629, 42629), + (42631, 42631), + (42633, 42633), + (42635, 42635), + (42637, 42637), + (42639, 42639), + (42641, 42641), + (42643, 42643), + (42645, 42645), + (42647, 42647), + (42649, 42649), + (42651, 42651), + (42787, 42787), + (42789, 42789), + (42791, 42791), + (42793, 42793), + (42795, 42795), + (42797, 42797), + (42799, 42801), + (42803, 42803), + (42805, 42805), + (42807, 42807), + (42809, 42809), + (42811, 42811), + (42813, 42813), + (42815, 42815), + (42817, 42817), + (42819, 42819), + (42821, 42821), + (42823, 42823), + (42825, 42825), + (42827, 42827), + (42829, 42829), + (42831, 42831), + (42833, 42833), + (42835, 42835), + (42837, 42837), + (42839, 42839), + (42841, 42841), + (42843, 42843), + (42845, 42845), + (42847, 42847), + (42849, 42849), + (42851, 42851), + (42853, 42853), + (42855, 42855), + (42857, 42857), + (42859, 42859), + (42861, 42861), + (42863, 42863), + (42865, 42872), + (42874, 42874), + (42876, 42876), + (42879, 42879), + (42881, 42881), + (42883, 42883), + (42885, 42885), + (42887, 42887), + (42892, 42892), + (42894, 42894), + (42897, 42897), + (42899, 42901), + (42903, 42903), + (42905, 42905), + (42907, 42907), + (42909, 42909), + (42911, 42911), + (42913, 42913), + (42915, 42915), + (42917, 42917), + (42919, 42919), + (42921, 42921), + (42927, 42927), + (42933, 42933), + (42935, 42935), + (42937, 42937), + (42939, 42939), + (42941, 42941), + (42943, 42943), + (42947, 42947), + (42952, 42952), + (42954, 42954), + (42998, 42998), + (43002, 43002), + (43824, 43866), + (43872, 43880), + (43888, 43967), + (64256, 64262), + (64275, 64279), + (65345, 65370), + (66600, 66639), + (66776, 66811), + (68800, 68850), + (71872, 71903), + (93792, 93823), + (119834, 119859), + (119886, 119892), + (119894, 119911), + (119938, 119963), + (119990, 119993), + (119995, 119995), + (119997, 120003), + (120005, 120015), + (120042, 120067), + (120094, 120119), + (120146, 120171), + (120198, 120223), + (120250, 120275), + (120302, 120327), + (120354, 120379), + (120406, 120431), + (120458, 120485), + (120514, 120538), + (120540, 120545), + (120572, 120596), + (120598, 120603), + (120630, 120654), + (120656, 120661), + (120688, 120712), + (120714, 120719), + (120746, 120770), + (120772, 120777), + (120779, 120779), + (125218, 125251), +]; + +pub const MARK: &'static [(u32, u32)] = &[ + (768, 879), + (1155, 1161), + (1425, 1469), + (1471, 1471), + (1473, 1474), + (1476, 1477), + (1479, 1479), + (1552, 1562), + (1611, 1631), + (1648, 1648), + (1750, 1756), + (1759, 1764), + (1767, 1768), + (1770, 1773), + (1809, 1809), + (1840, 1866), + (1958, 1968), + (2027, 2035), + (2045, 2045), + (2070, 2073), + (2075, 2083), + (2085, 2087), + (2089, 2093), + (2137, 2139), + (2259, 2273), + (2275, 2307), + (2362, 2364), + (2366, 2383), + (2385, 2391), + (2402, 2403), + (2433, 2435), + (2492, 2492), + (2494, 2500), + (2503, 2504), + (2507, 2509), + (2519, 2519), + (2530, 2531), + (2558, 2558), + (2561, 2563), + (2620, 2620), + (2622, 2626), + (2631, 2632), + (2635, 2637), + (2641, 2641), + (2672, 2673), + (2677, 2677), + (2689, 2691), + (2748, 2748), + (2750, 2757), + (2759, 2761), + (2763, 2765), + (2786, 2787), + (2810, 2815), + (2817, 2819), + (2876, 2876), + (2878, 2884), + (2887, 2888), + (2891, 2893), + (2901, 2903), + (2914, 2915), + (2946, 2946), + (3006, 3010), + (3014, 3016), + (3018, 3021), + (3031, 3031), + (3072, 3076), + (3134, 3140), + (3142, 3144), + (3146, 3149), + (3157, 3158), + (3170, 3171), + (3201, 3203), + (3260, 3260), + (3262, 3268), + (3270, 3272), + (3274, 3277), + (3285, 3286), + (3298, 3299), + (3328, 3331), + (3387, 3388), + (3390, 3396), + (3398, 3400), + (3402, 3405), + (3415, 3415), + (3426, 3427), + (3457, 3459), + (3530, 3530), + (3535, 3540), + (3542, 3542), + (3544, 3551), + (3570, 3571), + (3633, 3633), + (3636, 3642), + (3655, 3662), + (3761, 3761), + (3764, 3772), + (3784, 3789), + (3864, 3865), + (3893, 3893), + (3895, 3895), + (3897, 3897), + (3902, 3903), + (3953, 3972), + (3974, 3975), + (3981, 3991), + (3993, 4028), + (4038, 4038), + (4139, 4158), + (4182, 4185), + (4190, 4192), + (4194, 4196), + (4199, 4205), + (4209, 4212), + (4226, 4237), + (4239, 4239), + (4250, 4253), + (4957, 4959), + (5906, 5908), + (5938, 5940), + (5970, 5971), + (6002, 6003), + (6068, 6099), + (6109, 6109), + (6155, 6157), + (6277, 6278), + (6313, 6313), + (6432, 6443), + (6448, 6459), + (6679, 6683), + (6741, 6750), + (6752, 6780), + (6783, 6783), + (6832, 6848), + (6912, 6916), + (6964, 6980), + (7019, 7027), + (7040, 7042), + (7073, 7085), + (7142, 7155), + (7204, 7223), + (7376, 7378), + (7380, 7400), + (7405, 7405), + (7412, 7412), + (7415, 7417), + (7616, 7673), + (7675, 7679), + (8400, 8432), + (11503, 11505), + (11647, 11647), + (11744, 11775), + (12330, 12335), + (12441, 12442), + (42607, 42610), + (42612, 42621), + (42654, 42655), + (42736, 42737), + (43010, 43010), + (43014, 43014), + (43019, 43019), + (43043, 43047), + (43052, 43052), + (43136, 43137), + (43188, 43205), + (43232, 43249), + (43263, 43263), + (43302, 43309), + (43335, 43347), + (43392, 43395), + (43443, 43456), + (43493, 43493), + (43561, 43574), + (43587, 43587), + (43596, 43597), + (43643, 43645), + (43696, 43696), + (43698, 43700), + (43703, 43704), + (43710, 43711), + (43713, 43713), + (43755, 43759), + (43765, 43766), + (44003, 44010), + (44012, 44013), + (64286, 64286), + (65024, 65039), + (65056, 65071), + (66045, 66045), + (66272, 66272), + (66422, 66426), + (68097, 68099), + (68101, 68102), + (68108, 68111), + (68152, 68154), + (68159, 68159), + (68325, 68326), + (68900, 68903), + (69291, 69292), + (69446, 69456), + (69632, 69634), + (69688, 69702), + (69759, 69762), + (69808, 69818), + (69888, 69890), + (69927, 69940), + (69957, 69958), + (70003, 70003), + (70016, 70018), + (70067, 70080), + (70089, 70092), + (70094, 70095), + (70188, 70199), + (70206, 70206), + (70367, 70378), + (70400, 70403), + (70459, 70460), + (70462, 70468), + (70471, 70472), + (70475, 70477), + (70487, 70487), + (70498, 70499), + (70502, 70508), + (70512, 70516), + (70709, 70726), + (70750, 70750), + (70832, 70851), + (71087, 71093), + (71096, 71104), + (71132, 71133), + (71216, 71232), + (71339, 71351), + (71453, 71467), + (71724, 71738), + (71984, 71989), + (71991, 71992), + (71995, 71998), + (72000, 72000), + (72002, 72003), + (72145, 72151), + (72154, 72160), + (72164, 72164), + (72193, 72202), + (72243, 72249), + (72251, 72254), + (72263, 72263), + (72273, 72283), + (72330, 72345), + (72751, 72758), + (72760, 72767), + (72850, 72871), + (72873, 72886), + (73009, 73014), + (73018, 73018), + (73020, 73021), + (73023, 73029), + (73031, 73031), + (73098, 73102), + (73104, 73105), + (73107, 73111), + (73459, 73462), + (92912, 92916), + (92976, 92982), + (94031, 94031), + (94033, 94087), + (94095, 94098), + (94180, 94180), + (94192, 94193), + (113821, 113822), + (119141, 119145), + (119149, 119154), + (119163, 119170), + (119173, 119179), + (119210, 119213), + (119362, 119364), + (121344, 121398), + (121403, 121452), + (121461, 121461), + (121476, 121476), + (121499, 121503), + (121505, 121519), + (122880, 122886), + (122888, 122904), + (122907, 122913), + (122915, 122916), + (122918, 122922), + (123184, 123190), + (123628, 123631), + (125136, 125142), + (125252, 125258), + (917760, 917999), +]; + +pub const MATH_SYMBOL: &'static [(u32, u32)] = &[ + (43, 43), + (60, 62), + (124, 124), + (126, 126), + (172, 172), + (177, 177), + (215, 215), + (247, 247), + (1014, 1014), + (1542, 1544), + (8260, 8260), + (8274, 8274), + (8314, 8316), + (8330, 8332), + (8472, 8472), + (8512, 8516), + (8523, 8523), + (8592, 8596), + (8602, 8603), + (8608, 8608), + (8611, 8611), + (8614, 8614), + (8622, 8622), + (8654, 8655), + (8658, 8658), + (8660, 8660), + (8692, 8959), + (8992, 8993), + (9084, 9084), + (9115, 9139), + (9180, 9185), + (9655, 9655), + (9665, 9665), + (9720, 9727), + (9839, 9839), + (10176, 10180), + (10183, 10213), + (10224, 10239), + (10496, 10626), + (10649, 10711), + (10716, 10747), + (10750, 11007), + (11056, 11076), + (11079, 11084), + (64297, 64297), + (65122, 65122), + (65124, 65126), + (65291, 65291), + (65308, 65310), + (65372, 65372), + (65374, 65374), + (65506, 65506), + (65513, 65516), + (120513, 120513), + (120539, 120539), + (120571, 120571), + (120597, 120597), + (120629, 120629), + (120655, 120655), + (120687, 120687), + (120713, 120713), + (120745, 120745), + (120771, 120771), + (126704, 126705), +]; + +pub const MODIFIER_LETTER: &'static [(u32, u32)] = &[ + (688, 705), + (710, 721), + (736, 740), + (748, 748), + (750, 750), + (884, 884), + (890, 890), + (1369, 1369), + (1600, 1600), + (1765, 1766), + (2036, 2037), + (2042, 2042), + (2074, 2074), + (2084, 2084), + (2088, 2088), + (2417, 2417), + (3654, 3654), + (3782, 3782), + (4348, 4348), + (6103, 6103), + (6211, 6211), + (6823, 6823), + (7288, 7293), + (7468, 7530), + (7544, 7544), + (7579, 7615), + (8305, 8305), + (8319, 8319), + (8336, 8348), + (11388, 11389), + (11631, 11631), + (11823, 11823), + (12293, 12293), + (12337, 12341), + (12347, 12347), + (12445, 12446), + (12540, 12542), + (40981, 40981), + (42232, 42237), + (42508, 42508), + (42623, 42623), + (42652, 42653), + (42775, 42783), + (42864, 42864), + (42888, 42888), + (43000, 43001), + (43471, 43471), + (43494, 43494), + (43632, 43632), + (43741, 43741), + (43763, 43764), + (43868, 43871), + (43881, 43881), + (65392, 65392), + (65438, 65439), + (92992, 92995), + (94099, 94111), + (94176, 94177), + (94179, 94179), + (123191, 123197), + (125259, 125259), +]; + +pub const MODIFIER_SYMBOL: &'static [(u32, u32)] = &[ + (94, 94), + (96, 96), + (168, 168), + (175, 175), + (180, 180), + (184, 184), + (706, 709), + (722, 735), + (741, 747), + (749, 749), + (751, 767), + (885, 885), + (900, 901), + (8125, 8125), + (8127, 8129), + (8141, 8143), + (8157, 8159), + (8173, 8175), + (8189, 8190), + (12443, 12444), + (42752, 42774), + (42784, 42785), + (42889, 42890), + (43867, 43867), + (43882, 43883), + (64434, 64449), + (65342, 65342), + (65344, 65344), + (65507, 65507), + (127995, 127999), +]; + +pub const NONSPACING_MARK: &'static [(u32, u32)] = &[ + (768, 879), + (1155, 1159), + (1425, 1469), + (1471, 1471), + (1473, 1474), + (1476, 1477), + (1479, 1479), + (1552, 1562), + (1611, 1631), + (1648, 1648), + (1750, 1756), + (1759, 1764), + (1767, 1768), + (1770, 1773), + (1809, 1809), + (1840, 1866), + (1958, 1968), + (2027, 2035), + (2045, 2045), + (2070, 2073), + (2075, 2083), + (2085, 2087), + (2089, 2093), + (2137, 2139), + (2259, 2273), + (2275, 2306), + (2362, 2362), + (2364, 2364), + (2369, 2376), + (2381, 2381), + (2385, 2391), + (2402, 2403), + (2433, 2433), + (2492, 2492), + (2497, 2500), + (2509, 2509), + (2530, 2531), + (2558, 2558), + (2561, 2562), + (2620, 2620), + (2625, 2626), + (2631, 2632), + (2635, 2637), + (2641, 2641), + (2672, 2673), + (2677, 2677), + (2689, 2690), + (2748, 2748), + (2753, 2757), + (2759, 2760), + (2765, 2765), + (2786, 2787), + (2810, 2815), + (2817, 2817), + (2876, 2876), + (2879, 2879), + (2881, 2884), + (2893, 2893), + (2901, 2902), + (2914, 2915), + (2946, 2946), + (3008, 3008), + (3021, 3021), + (3072, 3072), + (3076, 3076), + (3134, 3136), + (3142, 3144), + (3146, 3149), + (3157, 3158), + (3170, 3171), + (3201, 3201), + (3260, 3260), + (3263, 3263), + (3270, 3270), + (3276, 3277), + (3298, 3299), + (3328, 3329), + (3387, 3388), + (3393, 3396), + (3405, 3405), + (3426, 3427), + (3457, 3457), + (3530, 3530), + (3538, 3540), + (3542, 3542), + (3633, 3633), + (3636, 3642), + (3655, 3662), + (3761, 3761), + (3764, 3772), + (3784, 3789), + (3864, 3865), + (3893, 3893), + (3895, 3895), + (3897, 3897), + (3953, 3966), + (3968, 3972), + (3974, 3975), + (3981, 3991), + (3993, 4028), + (4038, 4038), + (4141, 4144), + (4146, 4151), + (4153, 4154), + (4157, 4158), + (4184, 4185), + (4190, 4192), + (4209, 4212), + (4226, 4226), + (4229, 4230), + (4237, 4237), + (4253, 4253), + (4957, 4959), + (5906, 5908), + (5938, 5940), + (5970, 5971), + (6002, 6003), + (6068, 6069), + (6071, 6077), + (6086, 6086), + (6089, 6099), + (6109, 6109), + (6155, 6157), + (6277, 6278), + (6313, 6313), + (6432, 6434), + (6439, 6440), + (6450, 6450), + (6457, 6459), + (6679, 6680), + (6683, 6683), + (6742, 6742), + (6744, 6750), + (6752, 6752), + (6754, 6754), + (6757, 6764), + (6771, 6780), + (6783, 6783), + (6832, 6845), + (6847, 6848), + (6912, 6915), + (6964, 6964), + (6966, 6970), + (6972, 6972), + (6978, 6978), + (7019, 7027), + (7040, 7041), + (7074, 7077), + (7080, 7081), + (7083, 7085), + (7142, 7142), + (7144, 7145), + (7149, 7149), + (7151, 7153), + (7212, 7219), + (7222, 7223), + (7376, 7378), + (7380, 7392), + (7394, 7400), + (7405, 7405), + (7412, 7412), + (7416, 7417), + (7616, 7673), + (7675, 7679), + (8400, 8412), + (8417, 8417), + (8421, 8432), + (11503, 11505), + (11647, 11647), + (11744, 11775), + (12330, 12333), + (12441, 12442), + (42607, 42607), + (42612, 42621), + (42654, 42655), + (42736, 42737), + (43010, 43010), + (43014, 43014), + (43019, 43019), + (43045, 43046), + (43052, 43052), + (43204, 43205), + (43232, 43249), + (43263, 43263), + (43302, 43309), + (43335, 43345), + (43392, 43394), + (43443, 43443), + (43446, 43449), + (43452, 43453), + (43493, 43493), + (43561, 43566), + (43569, 43570), + (43573, 43574), + (43587, 43587), + (43596, 43596), + (43644, 43644), + (43696, 43696), + (43698, 43700), + (43703, 43704), + (43710, 43711), + (43713, 43713), + (43756, 43757), + (43766, 43766), + (44005, 44005), + (44008, 44008), + (44013, 44013), + (64286, 64286), + (65024, 65039), + (65056, 65071), + (66045, 66045), + (66272, 66272), + (66422, 66426), + (68097, 68099), + (68101, 68102), + (68108, 68111), + (68152, 68154), + (68159, 68159), + (68325, 68326), + (68900, 68903), + (69291, 69292), + (69446, 69456), + (69633, 69633), + (69688, 69702), + (69759, 69761), + (69811, 69814), + (69817, 69818), + (69888, 69890), + (69927, 69931), + (69933, 69940), + (70003, 70003), + (70016, 70017), + (70070, 70078), + (70089, 70092), + (70095, 70095), + (70191, 70193), + (70196, 70196), + (70198, 70199), + (70206, 70206), + (70367, 70367), + (70371, 70378), + (70400, 70401), + (70459, 70460), + (70464, 70464), + (70502, 70508), + (70512, 70516), + (70712, 70719), + (70722, 70724), + (70726, 70726), + (70750, 70750), + (70835, 70840), + (70842, 70842), + (70847, 70848), + (70850, 70851), + (71090, 71093), + (71100, 71101), + (71103, 71104), + (71132, 71133), + (71219, 71226), + (71229, 71229), + (71231, 71232), + (71339, 71339), + (71341, 71341), + (71344, 71349), + (71351, 71351), + (71453, 71455), + (71458, 71461), + (71463, 71467), + (71727, 71735), + (71737, 71738), + (71995, 71996), + (71998, 71998), + (72003, 72003), + (72148, 72151), + (72154, 72155), + (72160, 72160), + (72193, 72202), + (72243, 72248), + (72251, 72254), + (72263, 72263), + (72273, 72278), + (72281, 72283), + (72330, 72342), + (72344, 72345), + (72752, 72758), + (72760, 72765), + (72767, 72767), + (72850, 72871), + (72874, 72880), + (72882, 72883), + (72885, 72886), + (73009, 73014), + (73018, 73018), + (73020, 73021), + (73023, 73029), + (73031, 73031), + (73104, 73105), + (73109, 73109), + (73111, 73111), + (73459, 73460), + (92912, 92916), + (92976, 92982), + (94031, 94031), + (94095, 94098), + (94180, 94180), + (113821, 113822), + (119143, 119145), + (119163, 119170), + (119173, 119179), + (119210, 119213), + (119362, 119364), + (121344, 121398), + (121403, 121452), + (121461, 121461), + (121476, 121476), + (121499, 121503), + (121505, 121519), + (122880, 122886), + (122888, 122904), + (122907, 122913), + (122915, 122916), + (122918, 122922), + (123184, 123190), + (123628, 123631), + (125136, 125142), + (125252, 125258), + (917760, 917999), +]; + +pub const NUMBER: &'static [(u32, u32)] = &[ + (48, 57), + (178, 179), + (185, 185), + (188, 190), + (1632, 1641), + (1776, 1785), + (1984, 1993), + (2406, 2415), + (2534, 2543), + (2548, 2553), + (2662, 2671), + (2790, 2799), + (2918, 2927), + (2930, 2935), + (3046, 3058), + (3174, 3183), + (3192, 3198), + (3302, 3311), + (3416, 3422), + (3430, 3448), + (3558, 3567), + (3664, 3673), + (3792, 3801), + (3872, 3891), + (4160, 4169), + (4240, 4249), + (4969, 4988), + (5870, 5872), + (6112, 6121), + (6128, 6137), + (6160, 6169), + (6470, 6479), + (6608, 6618), + (6784, 6793), + (6800, 6809), + (6992, 7001), + (7088, 7097), + (7232, 7241), + (7248, 7257), + (8304, 8304), + (8308, 8313), + (8320, 8329), + (8528, 8578), + (8581, 8585), + (9312, 9371), + (9450, 9471), + (10102, 10131), + (11517, 11517), + (12295, 12295), + (12321, 12329), + (12344, 12346), + (12690, 12693), + (12832, 12841), + (12872, 12879), + (12881, 12895), + (12928, 12937), + (12977, 12991), + (42528, 42537), + (42726, 42735), + (43056, 43061), + (43216, 43225), + (43264, 43273), + (43472, 43481), + (43504, 43513), + (43600, 43609), + (44016, 44025), + (65296, 65305), + (65799, 65843), + (65856, 65912), + (65930, 65931), + (66273, 66299), + (66336, 66339), + (66369, 66369), + (66378, 66378), + (66513, 66517), + (66720, 66729), + (67672, 67679), + (67705, 67711), + (67751, 67759), + (67835, 67839), + (67862, 67867), + (68028, 68029), + (68032, 68047), + (68050, 68095), + (68160, 68168), + (68221, 68222), + (68253, 68255), + (68331, 68335), + (68440, 68447), + (68472, 68479), + (68521, 68527), + (68858, 68863), + (68912, 68921), + (69216, 69246), + (69405, 69414), + (69457, 69460), + (69573, 69579), + (69714, 69743), + (69872, 69881), + (69942, 69951), + (70096, 70105), + (70113, 70132), + (70384, 70393), + (70736, 70745), + (70864, 70873), + (71248, 71257), + (71360, 71369), + (71472, 71483), + (71904, 71922), + (72016, 72025), + (72784, 72812), + (73040, 73049), + (73120, 73129), + (73664, 73684), + (74752, 74862), + (92768, 92777), + (93008, 93017), + (93019, 93025), + (93824, 93846), + (119520, 119539), + (119648, 119672), + (120782, 120831), + (123200, 123209), + (123632, 123641), + (125127, 125135), + (125264, 125273), + (126065, 126123), + (126125, 126127), + (126129, 126132), + (126209, 126253), + (126255, 126269), + (127232, 127244), + (130032, 130041), +]; + +pub const OPEN_PUNCTUATION: &'static [(u32, u32)] = &[ + (40, 40), + (91, 91), + (123, 123), + (3898, 3898), + (3900, 3900), + (5787, 5787), + (8218, 8218), + (8222, 8222), + (8261, 8261), + (8317, 8317), + (8333, 8333), + (8968, 8968), + (8970, 8970), + (9001, 9001), + (10088, 10088), + (10090, 10090), + (10092, 10092), + (10094, 10094), + (10096, 10096), + (10098, 10098), + (10100, 10100), + (10181, 10181), + (10214, 10214), + (10216, 10216), + (10218, 10218), + (10220, 10220), + (10222, 10222), + (10627, 10627), + (10629, 10629), + (10631, 10631), + (10633, 10633), + (10635, 10635), + (10637, 10637), + (10639, 10639), + (10641, 10641), + (10643, 10643), + (10645, 10645), + (10647, 10647), + (10712, 10712), + (10714, 10714), + (10748, 10748), + (11810, 11810), + (11812, 11812), + (11814, 11814), + (11816, 11816), + (11842, 11842), + (12296, 12296), + (12298, 12298), + (12300, 12300), + (12302, 12302), + (12304, 12304), + (12308, 12308), + (12310, 12310), + (12312, 12312), + (12314, 12314), + (12317, 12317), + (64831, 64831), + (65047, 65047), + (65077, 65077), + (65079, 65079), + (65081, 65081), + (65083, 65083), + (65085, 65085), + (65087, 65087), + (65089, 65089), + (65091, 65091), + (65095, 65095), + (65113, 65113), + (65115, 65115), + (65117, 65117), + (65288, 65288), + (65339, 65339), + (65371, 65371), + (65375, 65375), + (65378, 65378), +]; + +pub const OTHER: &'static [(u32, u32)] = &[ + (0, 31), + (127, 159), + (173, 173), + (888, 889), + (896, 899), + (907, 907), + (909, 909), + (930, 930), + (1328, 1328), + (1367, 1368), + (1419, 1420), + (1424, 1424), + (1480, 1487), + (1515, 1518), + (1525, 1541), + (1564, 1565), + (1757, 1757), + (1806, 1807), + (1867, 1868), + (1970, 1983), + (2043, 2044), + (2094, 2095), + (2111, 2111), + (2140, 2141), + (2143, 2143), + (2155, 2207), + (2229, 2229), + (2248, 2258), + (2274, 2274), + (2436, 2436), + (2445, 2446), + (2449, 2450), + (2473, 2473), + (2481, 2481), + (2483, 2485), + (2490, 2491), + (2501, 2502), + (2505, 2506), + (2511, 2518), + (2520, 2523), + (2526, 2526), + (2532, 2533), + (2559, 2560), + (2564, 2564), + (2571, 2574), + (2577, 2578), + (2601, 2601), + (2609, 2609), + (2612, 2612), + (2615, 2615), + (2618, 2619), + (2621, 2621), + (2627, 2630), + (2633, 2634), + (2638, 2640), + (2642, 2648), + (2653, 2653), + (2655, 2661), + (2679, 2688), + (2692, 2692), + (2702, 2702), + (2706, 2706), + (2729, 2729), + (2737, 2737), + (2740, 2740), + (2746, 2747), + (2758, 2758), + (2762, 2762), + (2766, 2767), + (2769, 2783), + (2788, 2789), + (2802, 2808), + (2816, 2816), + (2820, 2820), + (2829, 2830), + (2833, 2834), + (2857, 2857), + (2865, 2865), + (2868, 2868), + (2874, 2875), + (2885, 2886), + (2889, 2890), + (2894, 2900), + (2904, 2907), + (2910, 2910), + (2916, 2917), + (2936, 2945), + (2948, 2948), + (2955, 2957), + (2961, 2961), + (2966, 2968), + (2971, 2971), + (2973, 2973), + (2976, 2978), + (2981, 2983), + (2987, 2989), + (3002, 3005), + (3011, 3013), + (3017, 3017), + (3022, 3023), + (3025, 3030), + (3032, 3045), + (3067, 3071), + (3085, 3085), + (3089, 3089), + (3113, 3113), + (3130, 3132), + (3141, 3141), + (3145, 3145), + (3150, 3156), + (3159, 3159), + (3163, 3167), + (3172, 3173), + (3184, 3190), + (3213, 3213), + (3217, 3217), + (3241, 3241), + (3252, 3252), + (3258, 3259), + (3269, 3269), + (3273, 3273), + (3278, 3284), + (3287, 3293), + (3295, 3295), + (3300, 3301), + (3312, 3312), + (3315, 3327), + (3341, 3341), + (3345, 3345), + (3397, 3397), + (3401, 3401), + (3408, 3411), + (3428, 3429), + (3456, 3456), + (3460, 3460), + (3479, 3481), + (3506, 3506), + (3516, 3516), + (3518, 3519), + (3527, 3529), + (3531, 3534), + (3541, 3541), + (3543, 3543), + (3552, 3557), + (3568, 3569), + (3573, 3584), + (3643, 3646), + (3676, 3712), + (3715, 3715), + (3717, 3717), + (3723, 3723), + (3748, 3748), + (3750, 3750), + (3774, 3775), + (3781, 3781), + (3783, 3783), + (3790, 3791), + (3802, 3803), + (3808, 3839), + (3912, 3912), + (3949, 3952), + (3992, 3992), + (4029, 4029), + (4045, 4045), + (4059, 4095), + (4294, 4294), + (4296, 4300), + (4302, 4303), + (4681, 4681), + (4686, 4687), + (4695, 4695), + (4697, 4697), + (4702, 4703), + (4745, 4745), + (4750, 4751), + (4785, 4785), + (4790, 4791), + (4799, 4799), + (4801, 4801), + (4806, 4807), + (4823, 4823), + (4881, 4881), + (4886, 4887), + (4955, 4956), + (4989, 4991), + (5018, 5023), + (5110, 5111), + (5118, 5119), + (5789, 5791), + (5881, 5887), + (5901, 5901), + (5909, 5919), + (5943, 5951), + (5972, 5983), + (5997, 5997), + (6001, 6001), + (6004, 6015), + (6110, 6111), + (6122, 6127), + (6138, 6143), + (6158, 6159), + (6170, 6175), + (6265, 6271), + (6315, 6319), + (6390, 6399), + (6431, 6431), + (6444, 6447), + (6460, 6463), + (6465, 6467), + (6510, 6511), + (6517, 6527), + (6572, 6575), + (6602, 6607), + (6619, 6621), + (6684, 6685), + (6751, 6751), + (6781, 6782), + (6794, 6799), + (6810, 6815), + (6830, 6831), + (6849, 6911), + (6988, 6991), + (7037, 7039), + (7156, 7163), + (7224, 7226), + (7242, 7244), + (7305, 7311), + (7355, 7356), + (7368, 7375), + (7419, 7423), + (7674, 7674), + (7958, 7959), + (7966, 7967), + (8006, 8007), + (8014, 8015), + (8024, 8024), + (8026, 8026), + (8028, 8028), + (8030, 8030), + (8062, 8063), + (8117, 8117), + (8133, 8133), + (8148, 8149), + (8156, 8156), + (8176, 8177), + (8181, 8181), + (8191, 8191), + (8203, 8207), + (8234, 8238), + (8288, 8303), + (8306, 8307), + (8335, 8335), + (8349, 8351), + (8384, 8399), + (8433, 8447), + (8588, 8591), + (9255, 9279), + (9291, 9311), + (11124, 11125), + (11158, 11158), + (11311, 11311), + (11359, 11359), + (11508, 11512), + (11558, 11558), + (11560, 11564), + (11566, 11567), + (11624, 11630), + (11633, 11646), + (11671, 11679), + (11687, 11687), + (11695, 11695), + (11703, 11703), + (11711, 11711), + (11719, 11719), + (11727, 11727), + (11735, 11735), + (11743, 11743), + (11859, 11903), + (11930, 11930), + (12020, 12031), + (12246, 12271), + (12284, 12287), + (12352, 12352), + (12439, 12440), + (12544, 12548), + (12592, 12592), + (12687, 12687), + (12772, 12783), + (12831, 12831), + (40957, 40959), + (42125, 42127), + (42183, 42191), + (42540, 42559), + (42744, 42751), + (42944, 42945), + (42955, 42996), + (43053, 43055), + (43066, 43071), + (43128, 43135), + (43206, 43213), + (43226, 43231), + (43348, 43358), + (43389, 43391), + (43470, 43470), + (43482, 43485), + (43519, 43519), + (43575, 43583), + (43598, 43599), + (43610, 43611), + (43715, 43738), + (43767, 43776), + (43783, 43784), + (43791, 43792), + (43799, 43807), + (43815, 43815), + (43823, 43823), + (43884, 43887), + (44014, 44015), + (44026, 44031), + (55204, 55215), + (55239, 55242), + (55292, 63743), + (64110, 64111), + (64218, 64255), + (64263, 64274), + (64280, 64284), + (64311, 64311), + (64317, 64317), + (64319, 64319), + (64322, 64322), + (64325, 64325), + (64450, 64466), + (64832, 64847), + (64912, 64913), + (64968, 65007), + (65022, 65023), + (65050, 65055), + (65107, 65107), + (65127, 65127), + (65132, 65135), + (65141, 65141), + (65277, 65280), + (65471, 65473), + (65480, 65481), + (65488, 65489), + (65496, 65497), + (65501, 65503), + (65511, 65511), + (65519, 65531), + (65534, 65535), + (65548, 65548), + (65575, 65575), + (65595, 65595), + (65598, 65598), + (65614, 65615), + (65630, 65663), + (65787, 65791), + (65795, 65798), + (65844, 65846), + (65935, 65935), + (65949, 65951), + (65953, 65999), + (66046, 66175), + (66205, 66207), + (66257, 66271), + (66300, 66303), + (66340, 66348), + (66379, 66383), + (66427, 66431), + (66462, 66462), + (66500, 66503), + (66518, 66559), + (66718, 66719), + (66730, 66735), + (66772, 66775), + (66812, 66815), + (66856, 66863), + (66916, 66926), + (66928, 67071), + (67383, 67391), + (67414, 67423), + (67432, 67583), + (67590, 67591), + (67593, 67593), + (67638, 67638), + (67641, 67643), + (67645, 67646), + (67670, 67670), + (67743, 67750), + (67760, 67807), + (67827, 67827), + (67830, 67834), + (67868, 67870), + (67898, 67902), + (67904, 67967), + (68024, 68027), + (68048, 68049), + (68100, 68100), + (68103, 68107), + (68116, 68116), + (68120, 68120), + (68150, 68151), + (68155, 68158), + (68169, 68175), + (68185, 68191), + (68256, 68287), + (68327, 68330), + (68343, 68351), + (68406, 68408), + (68438, 68439), + (68467, 68471), + (68498, 68504), + (68509, 68520), + (68528, 68607), + (68681, 68735), + (68787, 68799), + (68851, 68857), + (68904, 68911), + (68922, 69215), + (69247, 69247), + (69290, 69290), + (69294, 69295), + (69298, 69375), + (69416, 69423), + (69466, 69551), + (69580, 69599), + (69623, 69631), + (69710, 69713), + (69744, 69758), + (69821, 69821), + (69826, 69839), + (69865, 69871), + (69882, 69887), + (69941, 69941), + (69960, 69967), + (70007, 70015), + (70112, 70112), + (70133, 70143), + (70162, 70162), + (70207, 70271), + (70279, 70279), + (70281, 70281), + (70286, 70286), + (70302, 70302), + (70314, 70319), + (70379, 70383), + (70394, 70399), + (70404, 70404), + (70413, 70414), + (70417, 70418), + (70441, 70441), + (70449, 70449), + (70452, 70452), + (70458, 70458), + (70469, 70470), + (70473, 70474), + (70478, 70479), + (70481, 70486), + (70488, 70492), + (70500, 70501), + (70509, 70511), + (70517, 70655), + (70748, 70748), + (70754, 70783), + (70856, 70863), + (70874, 71039), + (71094, 71095), + (71134, 71167), + (71237, 71247), + (71258, 71263), + (71277, 71295), + (71353, 71359), + (71370, 71423), + (71451, 71452), + (71468, 71471), + (71488, 71679), + (71740, 71839), + (71923, 71934), + (71943, 71944), + (71946, 71947), + (71956, 71956), + (71959, 71959), + (71990, 71990), + (71993, 71994), + (72007, 72015), + (72026, 72095), + (72104, 72105), + (72152, 72153), + (72165, 72191), + (72264, 72271), + (72355, 72383), + (72441, 72703), + (72713, 72713), + (72759, 72759), + (72774, 72783), + (72813, 72815), + (72848, 72849), + (72872, 72872), + (72887, 72959), + (72967, 72967), + (72970, 72970), + (73015, 73017), + (73019, 73019), + (73022, 73022), + (73032, 73039), + (73050, 73055), + (73062, 73062), + (73065, 73065), + (73103, 73103), + (73106, 73106), + (73113, 73119), + (73130, 73439), + (73465, 73647), + (73649, 73663), + (73714, 73726), + (74650, 74751), + (74863, 74863), + (74869, 74879), + (75076, 77823), + (78895, 82943), + (83527, 92159), + (92729, 92735), + (92767, 92767), + (92778, 92781), + (92784, 92879), + (92910, 92911), + (92918, 92927), + (92998, 93007), + (93018, 93018), + (93026, 93026), + (93048, 93052), + (93072, 93759), + (93851, 93951), + (94027, 94030), + (94088, 94094), + (94112, 94175), + (94181, 94191), + (94194, 94207), + (100344, 100351), + (101590, 101631), + (101641, 110591), + (110879, 110927), + (110931, 110947), + (110952, 110959), + (111356, 113663), + (113771, 113775), + (113789, 113791), + (113801, 113807), + (113818, 113819), + (113824, 118783), + (119030, 119039), + (119079, 119080), + (119155, 119162), + (119273, 119295), + (119366, 119519), + (119540, 119551), + (119639, 119647), + (119673, 119807), + (119893, 119893), + (119965, 119965), + (119968, 119969), + (119971, 119972), + (119975, 119976), + (119981, 119981), + (119994, 119994), + (119996, 119996), + (120004, 120004), + (120070, 120070), + (120075, 120076), + (120085, 120085), + (120093, 120093), + (120122, 120122), + (120127, 120127), + (120133, 120133), + (120135, 120137), + (120145, 120145), + (120486, 120487), + (120780, 120781), + (121484, 121498), + (121504, 121504), + (121520, 122879), + (122887, 122887), + (122905, 122906), + (122914, 122914), + (122917, 122917), + (122923, 123135), + (123181, 123183), + (123198, 123199), + (123210, 123213), + (123216, 123583), + (123642, 123646), + (123648, 124927), + (125125, 125126), + (125143, 125183), + (125260, 125263), + (125274, 125277), + (125280, 126064), + (126133, 126208), + (126270, 126463), + (126468, 126468), + (126496, 126496), + (126499, 126499), + (126501, 126502), + (126504, 126504), + (126515, 126515), + (126520, 126520), + (126522, 126522), + (126524, 126529), + (126531, 126534), + (126536, 126536), + (126538, 126538), + (126540, 126540), + (126544, 126544), + (126547, 126547), + (126549, 126550), + (126552, 126552), + (126554, 126554), + (126556, 126556), + (126558, 126558), + (126560, 126560), + (126563, 126563), + (126565, 126566), + (126571, 126571), + (126579, 126579), + (126584, 126584), + (126589, 126589), + (126591, 126591), + (126602, 126602), + (126620, 126624), + (126628, 126628), + (126634, 126634), + (126652, 126703), + (126706, 126975), + (127020, 127023), + (127124, 127135), + (127151, 127152), + (127168, 127168), + (127184, 127184), + (127222, 127231), + (127406, 127461), + (127491, 127503), + (127548, 127551), + (127561, 127567), + (127570, 127583), + (127590, 127743), + (128728, 128735), + (128749, 128751), + (128765, 128767), + (128884, 128895), + (128985, 128991), + (129004, 129023), + (129036, 129039), + (129096, 129103), + (129114, 129119), + (129160, 129167), + (129198, 129199), + (129202, 129279), + (129401, 129401), + (129484, 129484), + (129620, 129631), + (129646, 129647), + (129653, 129655), + (129659, 129663), + (129671, 129679), + (129705, 129711), + (129719, 129727), + (129731, 129743), + (129751, 129791), + (129939, 129939), + (129995, 130031), + (130042, 131071), + (173790, 173823), + (177973, 177983), + (178206, 178207), + (183970, 183983), + (191457, 194559), + (195102, 196607), + (201547, 917759), + (918000, 1114111), +]; + +pub const OTHER_LETTER: &'static [(u32, u32)] = &[ + (170, 170), + (186, 186), + (443, 443), + (448, 451), + (660, 660), + (1488, 1514), + (1519, 1522), + (1568, 1599), + (1601, 1610), + (1646, 1647), + (1649, 1747), + (1749, 1749), + (1774, 1775), + (1786, 1788), + (1791, 1791), + (1808, 1808), + (1810, 1839), + (1869, 1957), + (1969, 1969), + (1994, 2026), + (2048, 2069), + (2112, 2136), + (2144, 2154), + (2208, 2228), + (2230, 2247), + (2308, 2361), + (2365, 2365), + (2384, 2384), + (2392, 2401), + (2418, 2432), + (2437, 2444), + (2447, 2448), + (2451, 2472), + (2474, 2480), + (2482, 2482), + (2486, 2489), + (2493, 2493), + (2510, 2510), + (2524, 2525), + (2527, 2529), + (2544, 2545), + (2556, 2556), + (2565, 2570), + (2575, 2576), + (2579, 2600), + (2602, 2608), + (2610, 2611), + (2613, 2614), + (2616, 2617), + (2649, 2652), + (2654, 2654), + (2674, 2676), + (2693, 2701), + (2703, 2705), + (2707, 2728), + (2730, 2736), + (2738, 2739), + (2741, 2745), + (2749, 2749), + (2768, 2768), + (2784, 2785), + (2809, 2809), + (2821, 2828), + (2831, 2832), + (2835, 2856), + (2858, 2864), + (2866, 2867), + (2869, 2873), + (2877, 2877), + (2908, 2909), + (2911, 2913), + (2929, 2929), + (2947, 2947), + (2949, 2954), + (2958, 2960), + (2962, 2965), + (2969, 2970), + (2972, 2972), + (2974, 2975), + (2979, 2980), + (2984, 2986), + (2990, 3001), + (3024, 3024), + (3077, 3084), + (3086, 3088), + (3090, 3112), + (3114, 3129), + (3133, 3133), + (3160, 3162), + (3168, 3169), + (3200, 3200), + (3205, 3212), + (3214, 3216), + (3218, 3240), + (3242, 3251), + (3253, 3257), + (3261, 3261), + (3294, 3294), + (3296, 3297), + (3313, 3314), + (3332, 3340), + (3342, 3344), + (3346, 3386), + (3389, 3389), + (3406, 3406), + (3412, 3414), + (3423, 3425), + (3450, 3455), + (3461, 3478), + (3482, 3505), + (3507, 3515), + (3517, 3517), + (3520, 3526), + (3585, 3632), + (3634, 3635), + (3648, 3653), + (3713, 3714), + (3716, 3716), + (3718, 3722), + (3724, 3747), + (3749, 3749), + (3751, 3760), + (3762, 3763), + (3773, 3773), + (3776, 3780), + (3804, 3807), + (3840, 3840), + (3904, 3911), + (3913, 3948), + (3976, 3980), + (4096, 4138), + (4159, 4159), + (4176, 4181), + (4186, 4189), + (4193, 4193), + (4197, 4198), + (4206, 4208), + (4213, 4225), + (4238, 4238), + (4352, 4680), + (4682, 4685), + (4688, 4694), + (4696, 4696), + (4698, 4701), + (4704, 4744), + (4746, 4749), + (4752, 4784), + (4786, 4789), + (4792, 4798), + (4800, 4800), + (4802, 4805), + (4808, 4822), + (4824, 4880), + (4882, 4885), + (4888, 4954), + (4992, 5007), + (5121, 5740), + (5743, 5759), + (5761, 5786), + (5792, 5866), + (5873, 5880), + (5888, 5900), + (5902, 5905), + (5920, 5937), + (5952, 5969), + (5984, 5996), + (5998, 6000), + (6016, 6067), + (6108, 6108), + (6176, 6210), + (6212, 6264), + (6272, 6276), + (6279, 6312), + (6314, 6314), + (6320, 6389), + (6400, 6430), + (6480, 6509), + (6512, 6516), + (6528, 6571), + (6576, 6601), + (6656, 6678), + (6688, 6740), + (6917, 6963), + (6981, 6987), + (7043, 7072), + (7086, 7087), + (7098, 7141), + (7168, 7203), + (7245, 7247), + (7258, 7287), + (7401, 7404), + (7406, 7411), + (7413, 7414), + (7418, 7418), + (8501, 8504), + (11568, 11623), + (11648, 11670), + (11680, 11686), + (11688, 11694), + (11696, 11702), + (11704, 11710), + (11712, 11718), + (11720, 11726), + (11728, 11734), + (11736, 11742), + (12294, 12294), + (12348, 12348), + (12353, 12438), + (12447, 12447), + (12449, 12538), + (12543, 12543), + (12549, 12591), + (12593, 12686), + (12704, 12735), + (12784, 12799), + (13312, 19903), + (19968, 40956), + (40960, 40980), + (40982, 42124), + (42192, 42231), + (42240, 42507), + (42512, 42527), + (42538, 42539), + (42606, 42606), + (42656, 42725), + (42895, 42895), + (42999, 42999), + (43003, 43009), + (43011, 43013), + (43015, 43018), + (43020, 43042), + (43072, 43123), + (43138, 43187), + (43250, 43255), + (43259, 43259), + (43261, 43262), + (43274, 43301), + (43312, 43334), + (43360, 43388), + (43396, 43442), + (43488, 43492), + (43495, 43503), + (43514, 43518), + (43520, 43560), + (43584, 43586), + (43588, 43595), + (43616, 43631), + (43633, 43638), + (43642, 43642), + (43646, 43695), + (43697, 43697), + (43701, 43702), + (43705, 43709), + (43712, 43712), + (43714, 43714), + (43739, 43740), + (43744, 43754), + (43762, 43762), + (43777, 43782), + (43785, 43790), + (43793, 43798), + (43808, 43814), + (43816, 43822), + (43968, 44002), + (44032, 55203), + (55216, 55238), + (55243, 55291), + (63744, 64109), + (64112, 64217), + (64285, 64285), + (64287, 64296), + (64298, 64310), + (64312, 64316), + (64318, 64318), + (64320, 64321), + (64323, 64324), + (64326, 64433), + (64467, 64829), + (64848, 64911), + (64914, 64967), + (65008, 65019), + (65136, 65140), + (65142, 65276), + (65382, 65391), + (65393, 65437), + (65440, 65470), + (65474, 65479), + (65482, 65487), + (65490, 65495), + (65498, 65500), + (65536, 65547), + (65549, 65574), + (65576, 65594), + (65596, 65597), + (65599, 65613), + (65616, 65629), + (65664, 65786), + (66176, 66204), + (66208, 66256), + (66304, 66335), + (66349, 66368), + (66370, 66377), + (66384, 66421), + (66432, 66461), + (66464, 66499), + (66504, 66511), + (66640, 66717), + (66816, 66855), + (66864, 66915), + (67072, 67382), + (67392, 67413), + (67424, 67431), + (67584, 67589), + (67592, 67592), + (67594, 67637), + (67639, 67640), + (67644, 67644), + (67647, 67669), + (67680, 67702), + (67712, 67742), + (67808, 67826), + (67828, 67829), + (67840, 67861), + (67872, 67897), + (67968, 68023), + (68030, 68031), + (68096, 68096), + (68112, 68115), + (68117, 68119), + (68121, 68149), + (68192, 68220), + (68224, 68252), + (68288, 68295), + (68297, 68324), + (68352, 68405), + (68416, 68437), + (68448, 68466), + (68480, 68497), + (68608, 68680), + (68864, 68899), + (69248, 69289), + (69296, 69297), + (69376, 69404), + (69415, 69415), + (69424, 69445), + (69552, 69572), + (69600, 69622), + (69635, 69687), + (69763, 69807), + (69840, 69864), + (69891, 69926), + (69956, 69956), + (69959, 69959), + (69968, 70002), + (70006, 70006), + (70019, 70066), + (70081, 70084), + (70106, 70106), + (70108, 70108), + (70144, 70161), + (70163, 70187), + (70272, 70278), + (70280, 70280), + (70282, 70285), + (70287, 70301), + (70303, 70312), + (70320, 70366), + (70405, 70412), + (70415, 70416), + (70419, 70440), + (70442, 70448), + (70450, 70451), + (70453, 70457), + (70461, 70461), + (70480, 70480), + (70493, 70497), + (70656, 70708), + (70727, 70730), + (70751, 70753), + (70784, 70831), + (70852, 70853), + (70855, 70855), + (71040, 71086), + (71128, 71131), + (71168, 71215), + (71236, 71236), + (71296, 71338), + (71352, 71352), + (71424, 71450), + (71680, 71723), + (71935, 71942), + (71945, 71945), + (71948, 71955), + (71957, 71958), + (71960, 71983), + (71999, 71999), + (72001, 72001), + (72096, 72103), + (72106, 72144), + (72161, 72161), + (72163, 72163), + (72192, 72192), + (72203, 72242), + (72250, 72250), + (72272, 72272), + (72284, 72329), + (72349, 72349), + (72384, 72440), + (72704, 72712), + (72714, 72750), + (72768, 72768), + (72818, 72847), + (72960, 72966), + (72968, 72969), + (72971, 73008), + (73030, 73030), + (73056, 73061), + (73063, 73064), + (73066, 73097), + (73112, 73112), + (73440, 73458), + (73648, 73648), + (73728, 74649), + (74880, 75075), + (77824, 78894), + (82944, 83526), + (92160, 92728), + (92736, 92766), + (92880, 92909), + (92928, 92975), + (93027, 93047), + (93053, 93071), + (93952, 94026), + (94032, 94032), + (94208, 100343), + (100352, 101589), + (101632, 101640), + (110592, 110878), + (110928, 110930), + (110948, 110951), + (110960, 111355), + (113664, 113770), + (113776, 113788), + (113792, 113800), + (113808, 113817), + (123136, 123180), + (123214, 123214), + (123584, 123627), + (124928, 125124), + (126464, 126467), + (126469, 126495), + (126497, 126498), + (126500, 126500), + (126503, 126503), + (126505, 126514), + (126516, 126519), + (126521, 126521), + (126523, 126523), + (126530, 126530), + (126535, 126535), + (126537, 126537), + (126539, 126539), + (126541, 126543), + (126545, 126546), + (126548, 126548), + (126551, 126551), + (126553, 126553), + (126555, 126555), + (126557, 126557), + (126559, 126559), + (126561, 126562), + (126564, 126564), + (126567, 126570), + (126572, 126578), + (126580, 126583), + (126585, 126588), + (126590, 126590), + (126592, 126601), + (126603, 126619), + (126625, 126627), + (126629, 126633), + (126635, 126651), + (131072, 173789), + (173824, 177972), + (177984, 178205), + (178208, 183969), + (183984, 191456), + (194560, 195101), + (196608, 201546), +]; + +pub const OTHER_NUMBER: &'static [(u32, u32)] = &[ + (178, 179), + (185, 185), + (188, 190), + (2548, 2553), + (2930, 2935), + (3056, 3058), + (3192, 3198), + (3416, 3422), + (3440, 3448), + (3882, 3891), + (4969, 4988), + (6128, 6137), + (6618, 6618), + (8304, 8304), + (8308, 8313), + (8320, 8329), + (8528, 8543), + (8585, 8585), + (9312, 9371), + (9450, 9471), + (10102, 10131), + (11517, 11517), + (12690, 12693), + (12832, 12841), + (12872, 12879), + (12881, 12895), + (12928, 12937), + (12977, 12991), + (43056, 43061), + (65799, 65843), + (65909, 65912), + (65930, 65931), + (66273, 66299), + (66336, 66339), + (67672, 67679), + (67705, 67711), + (67751, 67759), + (67835, 67839), + (67862, 67867), + (68028, 68029), + (68032, 68047), + (68050, 68095), + (68160, 68168), + (68221, 68222), + (68253, 68255), + (68331, 68335), + (68440, 68447), + (68472, 68479), + (68521, 68527), + (68858, 68863), + (69216, 69246), + (69405, 69414), + (69457, 69460), + (69573, 69579), + (69714, 69733), + (70113, 70132), + (71482, 71483), + (71914, 71922), + (72794, 72812), + (73664, 73684), + (93019, 93025), + (93824, 93846), + (119520, 119539), + (119648, 119672), + (125127, 125135), + (126065, 126123), + (126125, 126127), + (126129, 126132), + (126209, 126253), + (126255, 126269), + (127232, 127244), +]; + +pub const OTHER_PUNCTUATION: &'static [(u32, u32)] = &[ + (33, 35), + (37, 39), + (42, 42), + (44, 44), + (46, 47), + (58, 59), + (63, 64), + (92, 92), + (161, 161), + (167, 167), + (182, 183), + (191, 191), + (894, 894), + (903, 903), + (1370, 1375), + (1417, 1417), + (1472, 1472), + (1475, 1475), + (1478, 1478), + (1523, 1524), + (1545, 1546), + (1548, 1549), + (1563, 1563), + (1566, 1567), + (1642, 1645), + (1748, 1748), + (1792, 1805), + (2039, 2041), + (2096, 2110), + (2142, 2142), + (2404, 2405), + (2416, 2416), + (2557, 2557), + (2678, 2678), + (2800, 2800), + (3191, 3191), + (3204, 3204), + (3572, 3572), + (3663, 3663), + (3674, 3675), + (3844, 3858), + (3860, 3860), + (3973, 3973), + (4048, 4052), + (4057, 4058), + (4170, 4175), + (4347, 4347), + (4960, 4968), + (5742, 5742), + (5867, 5869), + (5941, 5942), + (6100, 6102), + (6104, 6106), + (6144, 6149), + (6151, 6154), + (6468, 6469), + (6686, 6687), + (6816, 6822), + (6824, 6829), + (7002, 7008), + (7164, 7167), + (7227, 7231), + (7294, 7295), + (7360, 7367), + (7379, 7379), + (8214, 8215), + (8224, 8231), + (8240, 8248), + (8251, 8254), + (8257, 8259), + (8263, 8273), + (8275, 8275), + (8277, 8286), + (11513, 11516), + (11518, 11519), + (11632, 11632), + (11776, 11777), + (11782, 11784), + (11787, 11787), + (11790, 11798), + (11800, 11801), + (11803, 11803), + (11806, 11807), + (11818, 11822), + (11824, 11833), + (11836, 11839), + (11841, 11841), + (11843, 11855), + (11858, 11858), + (12289, 12291), + (12349, 12349), + (12539, 12539), + (42238, 42239), + (42509, 42511), + (42611, 42611), + (42622, 42622), + (42738, 42743), + (43124, 43127), + (43214, 43215), + (43256, 43258), + (43260, 43260), + (43310, 43311), + (43359, 43359), + (43457, 43469), + (43486, 43487), + (43612, 43615), + (43742, 43743), + (43760, 43761), + (44011, 44011), + (65040, 65046), + (65049, 65049), + (65072, 65072), + (65093, 65094), + (65097, 65100), + (65104, 65106), + (65108, 65111), + (65119, 65121), + (65128, 65128), + (65130, 65131), + (65281, 65283), + (65285, 65287), + (65290, 65290), + (65292, 65292), + (65294, 65295), + (65306, 65307), + (65311, 65312), + (65340, 65340), + (65377, 65377), + (65380, 65381), + (65792, 65794), + (66463, 66463), + (66512, 66512), + (66927, 66927), + (67671, 67671), + (67871, 67871), + (67903, 67903), + (68176, 68184), + (68223, 68223), + (68336, 68342), + (68409, 68415), + (68505, 68508), + (69461, 69465), + (69703, 69709), + (69819, 69820), + (69822, 69825), + (69952, 69955), + (70004, 70005), + (70085, 70088), + (70093, 70093), + (70107, 70107), + (70109, 70111), + (70200, 70205), + (70313, 70313), + (70731, 70735), + (70746, 70747), + (70749, 70749), + (70854, 70854), + (71105, 71127), + (71233, 71235), + (71264, 71276), + (71484, 71486), + (71739, 71739), + (72004, 72006), + (72162, 72162), + (72255, 72262), + (72346, 72348), + (72350, 72354), + (72769, 72773), + (72816, 72817), + (73463, 73464), + (73727, 73727), + (74864, 74868), + (92782, 92783), + (92917, 92917), + (92983, 92987), + (92996, 92996), + (93847, 93850), + (94178, 94178), + (113823, 113823), + (121479, 121483), + (125278, 125279), +]; + +pub const OTHER_SYMBOL: &'static [(u32, u32)] = &[ + (166, 166), + (169, 169), + (174, 174), + (176, 176), + (1154, 1154), + (1421, 1422), + (1550, 1551), + (1758, 1758), + (1769, 1769), + (1789, 1790), + (2038, 2038), + (2554, 2554), + (2928, 2928), + (3059, 3064), + (3066, 3066), + (3199, 3199), + (3407, 3407), + (3449, 3449), + (3841, 3843), + (3859, 3859), + (3861, 3863), + (3866, 3871), + (3892, 3892), + (3894, 3894), + (3896, 3896), + (4030, 4037), + (4039, 4044), + (4046, 4047), + (4053, 4056), + (4254, 4255), + (5008, 5017), + (5741, 5741), + (6464, 6464), + (6622, 6655), + (7009, 7018), + (7028, 7036), + (8448, 8449), + (8451, 8454), + (8456, 8457), + (8468, 8468), + (8470, 8471), + (8478, 8483), + (8485, 8485), + (8487, 8487), + (8489, 8489), + (8494, 8494), + (8506, 8507), + (8522, 8522), + (8524, 8525), + (8527, 8527), + (8586, 8587), + (8597, 8601), + (8604, 8607), + (8609, 8610), + (8612, 8613), + (8615, 8621), + (8623, 8653), + (8656, 8657), + (8659, 8659), + (8661, 8691), + (8960, 8967), + (8972, 8991), + (8994, 9000), + (9003, 9083), + (9085, 9114), + (9140, 9179), + (9186, 9254), + (9280, 9290), + (9372, 9449), + (9472, 9654), + (9656, 9664), + (9666, 9719), + (9728, 9838), + (9840, 10087), + (10132, 10175), + (10240, 10495), + (11008, 11055), + (11077, 11078), + (11085, 11123), + (11126, 11157), + (11159, 11263), + (11493, 11498), + (11856, 11857), + (11904, 11929), + (11931, 12019), + (12032, 12245), + (12272, 12283), + (12292, 12292), + (12306, 12307), + (12320, 12320), + (12342, 12343), + (12350, 12351), + (12688, 12689), + (12694, 12703), + (12736, 12771), + (12800, 12830), + (12842, 12871), + (12880, 12880), + (12896, 12927), + (12938, 12976), + (12992, 13311), + (19904, 19967), + (42128, 42182), + (43048, 43051), + (43062, 43063), + (43065, 43065), + (43639, 43641), + (65021, 65021), + (65508, 65508), + (65512, 65512), + (65517, 65518), + (65532, 65533), + (65847, 65855), + (65913, 65929), + (65932, 65934), + (65936, 65948), + (65952, 65952), + (66000, 66044), + (67703, 67704), + (68296, 68296), + (71487, 71487), + (73685, 73692), + (73697, 73713), + (92988, 92991), + (92997, 92997), + (113820, 113820), + (118784, 119029), + (119040, 119078), + (119081, 119140), + (119146, 119148), + (119171, 119172), + (119180, 119209), + (119214, 119272), + (119296, 119361), + (119365, 119365), + (119552, 119638), + (120832, 121343), + (121399, 121402), + (121453, 121460), + (121462, 121475), + (121477, 121478), + (123215, 123215), + (126124, 126124), + (126254, 126254), + (126976, 127019), + (127024, 127123), + (127136, 127150), + (127153, 127167), + (127169, 127183), + (127185, 127221), + (127245, 127405), + (127462, 127490), + (127504, 127547), + (127552, 127560), + (127568, 127569), + (127584, 127589), + (127744, 127994), + (128000, 128727), + (128736, 128748), + (128752, 128764), + (128768, 128883), + (128896, 128984), + (128992, 129003), + (129024, 129035), + (129040, 129095), + (129104, 129113), + (129120, 129159), + (129168, 129197), + (129200, 129201), + (129280, 129400), + (129402, 129483), + (129485, 129619), + (129632, 129645), + (129648, 129652), + (129656, 129658), + (129664, 129670), + (129680, 129704), + (129712, 129718), + (129728, 129730), + (129744, 129750), + (129792, 129938), + (129940, 129994), +]; + +pub const PARAGRAPH_SEPARATOR: &'static [(u32, u32)] = &[(8233, 8233)]; + +pub const PRIVATE_USE: &'static [(u32, u32)] = + &[(57344, 63743), (983040, 1048573), (1048576, 1114109)]; + +pub const PUNCTUATION: &'static [(u32, u32)] = &[ + (33, 35), + (37, 42), + (44, 47), + (58, 59), + (63, 64), + (91, 93), + (95, 95), + (123, 123), + (125, 125), + (161, 161), + (167, 167), + (171, 171), + (182, 183), + (187, 187), + (191, 191), + (894, 894), + (903, 903), + (1370, 1375), + (1417, 1418), + (1470, 1470), + (1472, 1472), + (1475, 1475), + (1478, 1478), + (1523, 1524), + (1545, 1546), + (1548, 1549), + (1563, 1563), + (1566, 1567), + (1642, 1645), + (1748, 1748), + (1792, 1805), + (2039, 2041), + (2096, 2110), + (2142, 2142), + (2404, 2405), + (2416, 2416), + (2557, 2557), + (2678, 2678), + (2800, 2800), + (3191, 3191), + (3204, 3204), + (3572, 3572), + (3663, 3663), + (3674, 3675), + (3844, 3858), + (3860, 3860), + (3898, 3901), + (3973, 3973), + (4048, 4052), + (4057, 4058), + (4170, 4175), + (4347, 4347), + (4960, 4968), + (5120, 5120), + (5742, 5742), + (5787, 5788), + (5867, 5869), + (5941, 5942), + (6100, 6102), + (6104, 6106), + (6144, 6154), + (6468, 6469), + (6686, 6687), + (6816, 6822), + (6824, 6829), + (7002, 7008), + (7164, 7167), + (7227, 7231), + (7294, 7295), + (7360, 7367), + (7379, 7379), + (8208, 8231), + (8240, 8259), + (8261, 8273), + (8275, 8286), + (8317, 8318), + (8333, 8334), + (8968, 8971), + (9001, 9002), + (10088, 10101), + (10181, 10182), + (10214, 10223), + (10627, 10648), + (10712, 10715), + (10748, 10749), + (11513, 11516), + (11518, 11519), + (11632, 11632), + (11776, 11822), + (11824, 11855), + (11858, 11858), + (12289, 12291), + (12296, 12305), + (12308, 12319), + (12336, 12336), + (12349, 12349), + (12448, 12448), + (12539, 12539), + (42238, 42239), + (42509, 42511), + (42611, 42611), + (42622, 42622), + (42738, 42743), + (43124, 43127), + (43214, 43215), + (43256, 43258), + (43260, 43260), + (43310, 43311), + (43359, 43359), + (43457, 43469), + (43486, 43487), + (43612, 43615), + (43742, 43743), + (43760, 43761), + (44011, 44011), + (64830, 64831), + (65040, 65049), + (65072, 65106), + (65108, 65121), + (65123, 65123), + (65128, 65128), + (65130, 65131), + (65281, 65283), + (65285, 65290), + (65292, 65295), + (65306, 65307), + (65311, 65312), + (65339, 65341), + (65343, 65343), + (65371, 65371), + (65373, 65373), + (65375, 65381), + (65792, 65794), + (66463, 66463), + (66512, 66512), + (66927, 66927), + (67671, 67671), + (67871, 67871), + (67903, 67903), + (68176, 68184), + (68223, 68223), + (68336, 68342), + (68409, 68415), + (68505, 68508), + (69293, 69293), + (69461, 69465), + (69703, 69709), + (69819, 69820), + (69822, 69825), + (69952, 69955), + (70004, 70005), + (70085, 70088), + (70093, 70093), + (70107, 70107), + (70109, 70111), + (70200, 70205), + (70313, 70313), + (70731, 70735), + (70746, 70747), + (70749, 70749), + (70854, 70854), + (71105, 71127), + (71233, 71235), + (71264, 71276), + (71484, 71486), + (71739, 71739), + (72004, 72006), + (72162, 72162), + (72255, 72262), + (72346, 72348), + (72350, 72354), + (72769, 72773), + (72816, 72817), + (73463, 73464), + (73727, 73727), + (74864, 74868), + (92782, 92783), + (92917, 92917), + (92983, 92987), + (92996, 92996), + (93847, 93850), + (94178, 94178), + (113823, 113823), + (121479, 121483), + (125278, 125279), +]; + +pub const SEPARATOR: &'static [(u32, u32)] = &[ + (32, 32), + (160, 160), + (5760, 5760), + (8192, 8202), + (8232, 8233), + (8239, 8239), + (8287, 8287), + (12288, 12288), +]; + +pub const SPACE_SEPARATOR: &'static [(u32, u32)] = &[ + (32, 32), + (160, 160), + (5760, 5760), + (8192, 8202), + (8239, 8239), + (8287, 8287), + (12288, 12288), +]; + +pub const SPACING_MARK: &'static [(u32, u32)] = &[ + (2307, 2307), + (2363, 2363), + (2366, 2368), + (2377, 2380), + (2382, 2383), + (2434, 2435), + (2494, 2496), + (2503, 2504), + (2507, 2508), + (2519, 2519), + (2563, 2563), + (2622, 2624), + (2691, 2691), + (2750, 2752), + (2761, 2761), + (2763, 2764), + (2818, 2819), + (2878, 2878), + (2880, 2880), + (2887, 2888), + (2891, 2892), + (2903, 2903), + (3006, 3007), + (3009, 3010), + (3014, 3016), + (3018, 3020), + (3031, 3031), + (3073, 3075), + (3137, 3140), + (3202, 3203), + (3262, 3262), + (3264, 3268), + (3271, 3272), + (3274, 3275), + (3285, 3286), + (3330, 3331), + (3390, 3392), + (3398, 3400), + (3402, 3404), + (3415, 3415), + (3458, 3459), + (3535, 3537), + (3544, 3551), + (3570, 3571), + (3902, 3903), + (3967, 3967), + (4139, 4140), + (4145, 4145), + (4152, 4152), + (4155, 4156), + (4182, 4183), + (4194, 4196), + (4199, 4205), + (4227, 4228), + (4231, 4236), + (4239, 4239), + (4250, 4252), + (6070, 6070), + (6078, 6085), + (6087, 6088), + (6435, 6438), + (6441, 6443), + (6448, 6449), + (6451, 6456), + (6681, 6682), + (6741, 6741), + (6743, 6743), + (6753, 6753), + (6755, 6756), + (6765, 6770), + (6916, 6916), + (6965, 6965), + (6971, 6971), + (6973, 6977), + (6979, 6980), + (7042, 7042), + (7073, 7073), + (7078, 7079), + (7082, 7082), + (7143, 7143), + (7146, 7148), + (7150, 7150), + (7154, 7155), + (7204, 7211), + (7220, 7221), + (7393, 7393), + (7415, 7415), + (12334, 12335), + (43043, 43044), + (43047, 43047), + (43136, 43137), + (43188, 43203), + (43346, 43347), + (43395, 43395), + (43444, 43445), + (43450, 43451), + (43454, 43456), + (43567, 43568), + (43571, 43572), + (43597, 43597), + (43643, 43643), + (43645, 43645), + (43755, 43755), + (43758, 43759), + (43765, 43765), + (44003, 44004), + (44006, 44007), + (44009, 44010), + (44012, 44012), + (69632, 69632), + (69634, 69634), + (69762, 69762), + (69808, 69810), + (69815, 69816), + (69932, 69932), + (69957, 69958), + (70018, 70018), + (70067, 70069), + (70079, 70080), + (70094, 70094), + (70188, 70190), + (70194, 70195), + (70197, 70197), + (70368, 70370), + (70402, 70403), + (70462, 70463), + (70465, 70468), + (70471, 70472), + (70475, 70477), + (70487, 70487), + (70498, 70499), + (70709, 70711), + (70720, 70721), + (70725, 70725), + (70832, 70834), + (70841, 70841), + (70843, 70846), + (70849, 70849), + (71087, 71089), + (71096, 71099), + (71102, 71102), + (71216, 71218), + (71227, 71228), + (71230, 71230), + (71340, 71340), + (71342, 71343), + (71350, 71350), + (71456, 71457), + (71462, 71462), + (71724, 71726), + (71736, 71736), + (71984, 71989), + (71991, 71992), + (71997, 71997), + (72000, 72000), + (72002, 72002), + (72145, 72147), + (72156, 72159), + (72164, 72164), + (72249, 72249), + (72279, 72280), + (72343, 72343), + (72751, 72751), + (72766, 72766), + (72873, 72873), + (72881, 72881), + (72884, 72884), + (73098, 73102), + (73107, 73108), + (73110, 73110), + (73461, 73462), + (94033, 94087), + (94192, 94193), + (119141, 119142), + (119149, 119154), +]; + +pub const SURROGATE: &'static [(u32, u32)] = &[(55296, 57343)]; + +pub const SYMBOL: &'static [(u32, u32)] = &[ + (36, 36), + (43, 43), + (60, 62), + (94, 94), + (96, 96), + (124, 124), + (126, 126), + (162, 166), + (168, 169), + (172, 172), + (174, 177), + (180, 180), + (184, 184), + (215, 215), + (247, 247), + (706, 709), + (722, 735), + (741, 747), + (749, 749), + (751, 767), + (885, 885), + (900, 901), + (1014, 1014), + (1154, 1154), + (1421, 1423), + (1542, 1544), + (1547, 1547), + (1550, 1551), + (1758, 1758), + (1769, 1769), + (1789, 1790), + (2038, 2038), + (2046, 2047), + (2546, 2547), + (2554, 2555), + (2801, 2801), + (2928, 2928), + (3059, 3066), + (3199, 3199), + (3407, 3407), + (3449, 3449), + (3647, 3647), + (3841, 3843), + (3859, 3859), + (3861, 3863), + (3866, 3871), + (3892, 3892), + (3894, 3894), + (3896, 3896), + (4030, 4037), + (4039, 4044), + (4046, 4047), + (4053, 4056), + (4254, 4255), + (5008, 5017), + (5741, 5741), + (6107, 6107), + (6464, 6464), + (6622, 6655), + (7009, 7018), + (7028, 7036), + (8125, 8125), + (8127, 8129), + (8141, 8143), + (8157, 8159), + (8173, 8175), + (8189, 8190), + (8260, 8260), + (8274, 8274), + (8314, 8316), + (8330, 8332), + (8352, 8383), + (8448, 8449), + (8451, 8454), + (8456, 8457), + (8468, 8468), + (8470, 8472), + (8478, 8483), + (8485, 8485), + (8487, 8487), + (8489, 8489), + (8494, 8494), + (8506, 8507), + (8512, 8516), + (8522, 8525), + (8527, 8527), + (8586, 8587), + (8592, 8967), + (8972, 9000), + (9003, 9254), + (9280, 9290), + (9372, 9449), + (9472, 10087), + (10132, 10180), + (10183, 10213), + (10224, 10626), + (10649, 10711), + (10716, 10747), + (10750, 11123), + (11126, 11157), + (11159, 11263), + (11493, 11498), + (11856, 11857), + (11904, 11929), + (11931, 12019), + (12032, 12245), + (12272, 12283), + (12292, 12292), + (12306, 12307), + (12320, 12320), + (12342, 12343), + (12350, 12351), + (12443, 12444), + (12688, 12689), + (12694, 12703), + (12736, 12771), + (12800, 12830), + (12842, 12871), + (12880, 12880), + (12896, 12927), + (12938, 12976), + (12992, 13311), + (19904, 19967), + (42128, 42182), + (42752, 42774), + (42784, 42785), + (42889, 42890), + (43048, 43051), + (43062, 43065), + (43639, 43641), + (43867, 43867), + (43882, 43883), + (64297, 64297), + (64434, 64449), + (65020, 65021), + (65122, 65122), + (65124, 65126), + (65129, 65129), + (65284, 65284), + (65291, 65291), + (65308, 65310), + (65342, 65342), + (65344, 65344), + (65372, 65372), + (65374, 65374), + (65504, 65510), + (65512, 65518), + (65532, 65533), + (65847, 65855), + (65913, 65929), + (65932, 65934), + (65936, 65948), + (65952, 65952), + (66000, 66044), + (67703, 67704), + (68296, 68296), + (71487, 71487), + (73685, 73713), + (92988, 92991), + (92997, 92997), + (113820, 113820), + (118784, 119029), + (119040, 119078), + (119081, 119140), + (119146, 119148), + (119171, 119172), + (119180, 119209), + (119214, 119272), + (119296, 119361), + (119365, 119365), + (119552, 119638), + (120513, 120513), + (120539, 120539), + (120571, 120571), + (120597, 120597), + (120629, 120629), + (120655, 120655), + (120687, 120687), + (120713, 120713), + (120745, 120745), + (120771, 120771), + (120832, 121343), + (121399, 121402), + (121453, 121460), + (121462, 121475), + (121477, 121478), + (123215, 123215), + (123647, 123647), + (126124, 126124), + (126128, 126128), + (126254, 126254), + (126704, 126705), + (126976, 127019), + (127024, 127123), + (127136, 127150), + (127153, 127167), + (127169, 127183), + (127185, 127221), + (127245, 127405), + (127462, 127490), + (127504, 127547), + (127552, 127560), + (127568, 127569), + (127584, 127589), + (127744, 128727), + (128736, 128748), + (128752, 128764), + (128768, 128883), + (128896, 128984), + (128992, 129003), + (129024, 129035), + (129040, 129095), + (129104, 129113), + (129120, 129159), + (129168, 129197), + (129200, 129201), + (129280, 129400), + (129402, 129483), + (129485, 129619), + (129632, 129645), + (129648, 129652), + (129656, 129658), + (129664, 129670), + (129680, 129704), + (129712, 129718), + (129728, 129730), + (129744, 129750), + (129792, 129938), + (129940, 129994), +]; + +pub const TITLECASE_LETTER: &'static [(u32, u32)] = &[ + (453, 453), + (456, 456), + (459, 459), + (498, 498), + (8072, 8079), + (8088, 8095), + (8104, 8111), + (8124, 8124), + (8140, 8140), + (8188, 8188), +]; + +pub const UNASSIGNED: &'static [(u32, u32)] = &[ + (888, 889), + (896, 899), + (907, 907), + (909, 909), + (930, 930), + (1328, 1328), + (1367, 1368), + (1419, 1420), + (1424, 1424), + (1480, 1487), + (1515, 1518), + (1525, 1535), + (1565, 1565), + (1806, 1806), + (1867, 1868), + (1970, 1983), + (2043, 2044), + (2094, 2095), + (2111, 2111), + (2140, 2141), + (2143, 2143), + (2155, 2207), + (2229, 2229), + (2248, 2258), + (2436, 2436), + (2445, 2446), + (2449, 2450), + (2473, 2473), + (2481, 2481), + (2483, 2485), + (2490, 2491), + (2501, 2502), + (2505, 2506), + (2511, 2518), + (2520, 2523), + (2526, 2526), + (2532, 2533), + (2559, 2560), + (2564, 2564), + (2571, 2574), + (2577, 2578), + (2601, 2601), + (2609, 2609), + (2612, 2612), + (2615, 2615), + (2618, 2619), + (2621, 2621), + (2627, 2630), + (2633, 2634), + (2638, 2640), + (2642, 2648), + (2653, 2653), + (2655, 2661), + (2679, 2688), + (2692, 2692), + (2702, 2702), + (2706, 2706), + (2729, 2729), + (2737, 2737), + (2740, 2740), + (2746, 2747), + (2758, 2758), + (2762, 2762), + (2766, 2767), + (2769, 2783), + (2788, 2789), + (2802, 2808), + (2816, 2816), + (2820, 2820), + (2829, 2830), + (2833, 2834), + (2857, 2857), + (2865, 2865), + (2868, 2868), + (2874, 2875), + (2885, 2886), + (2889, 2890), + (2894, 2900), + (2904, 2907), + (2910, 2910), + (2916, 2917), + (2936, 2945), + (2948, 2948), + (2955, 2957), + (2961, 2961), + (2966, 2968), + (2971, 2971), + (2973, 2973), + (2976, 2978), + (2981, 2983), + (2987, 2989), + (3002, 3005), + (3011, 3013), + (3017, 3017), + (3022, 3023), + (3025, 3030), + (3032, 3045), + (3067, 3071), + (3085, 3085), + (3089, 3089), + (3113, 3113), + (3130, 3132), + (3141, 3141), + (3145, 3145), + (3150, 3156), + (3159, 3159), + (3163, 3167), + (3172, 3173), + (3184, 3190), + (3213, 3213), + (3217, 3217), + (3241, 3241), + (3252, 3252), + (3258, 3259), + (3269, 3269), + (3273, 3273), + (3278, 3284), + (3287, 3293), + (3295, 3295), + (3300, 3301), + (3312, 3312), + (3315, 3327), + (3341, 3341), + (3345, 3345), + (3397, 3397), + (3401, 3401), + (3408, 3411), + (3428, 3429), + (3456, 3456), + (3460, 3460), + (3479, 3481), + (3506, 3506), + (3516, 3516), + (3518, 3519), + (3527, 3529), + (3531, 3534), + (3541, 3541), + (3543, 3543), + (3552, 3557), + (3568, 3569), + (3573, 3584), + (3643, 3646), + (3676, 3712), + (3715, 3715), + (3717, 3717), + (3723, 3723), + (3748, 3748), + (3750, 3750), + (3774, 3775), + (3781, 3781), + (3783, 3783), + (3790, 3791), + (3802, 3803), + (3808, 3839), + (3912, 3912), + (3949, 3952), + (3992, 3992), + (4029, 4029), + (4045, 4045), + (4059, 4095), + (4294, 4294), + (4296, 4300), + (4302, 4303), + (4681, 4681), + (4686, 4687), + (4695, 4695), + (4697, 4697), + (4702, 4703), + (4745, 4745), + (4750, 4751), + (4785, 4785), + (4790, 4791), + (4799, 4799), + (4801, 4801), + (4806, 4807), + (4823, 4823), + (4881, 4881), + (4886, 4887), + (4955, 4956), + (4989, 4991), + (5018, 5023), + (5110, 5111), + (5118, 5119), + (5789, 5791), + (5881, 5887), + (5901, 5901), + (5909, 5919), + (5943, 5951), + (5972, 5983), + (5997, 5997), + (6001, 6001), + (6004, 6015), + (6110, 6111), + (6122, 6127), + (6138, 6143), + (6159, 6159), + (6170, 6175), + (6265, 6271), + (6315, 6319), + (6390, 6399), + (6431, 6431), + (6444, 6447), + (6460, 6463), + (6465, 6467), + (6510, 6511), + (6517, 6527), + (6572, 6575), + (6602, 6607), + (6619, 6621), + (6684, 6685), + (6751, 6751), + (6781, 6782), + (6794, 6799), + (6810, 6815), + (6830, 6831), + (6849, 6911), + (6988, 6991), + (7037, 7039), + (7156, 7163), + (7224, 7226), + (7242, 7244), + (7305, 7311), + (7355, 7356), + (7368, 7375), + (7419, 7423), + (7674, 7674), + (7958, 7959), + (7966, 7967), + (8006, 8007), + (8014, 8015), + (8024, 8024), + (8026, 8026), + (8028, 8028), + (8030, 8030), + (8062, 8063), + (8117, 8117), + (8133, 8133), + (8148, 8149), + (8156, 8156), + (8176, 8177), + (8181, 8181), + (8191, 8191), + (8293, 8293), + (8306, 8307), + (8335, 8335), + (8349, 8351), + (8384, 8399), + (8433, 8447), + (8588, 8591), + (9255, 9279), + (9291, 9311), + (11124, 11125), + (11158, 11158), + (11311, 11311), + (11359, 11359), + (11508, 11512), + (11558, 11558), + (11560, 11564), + (11566, 11567), + (11624, 11630), + (11633, 11646), + (11671, 11679), + (11687, 11687), + (11695, 11695), + (11703, 11703), + (11711, 11711), + (11719, 11719), + (11727, 11727), + (11735, 11735), + (11743, 11743), + (11859, 11903), + (11930, 11930), + (12020, 12031), + (12246, 12271), + (12284, 12287), + (12352, 12352), + (12439, 12440), + (12544, 12548), + (12592, 12592), + (12687, 12687), + (12772, 12783), + (12831, 12831), + (40957, 40959), + (42125, 42127), + (42183, 42191), + (42540, 42559), + (42744, 42751), + (42944, 42945), + (42955, 42996), + (43053, 43055), + (43066, 43071), + (43128, 43135), + (43206, 43213), + (43226, 43231), + (43348, 43358), + (43389, 43391), + (43470, 43470), + (43482, 43485), + (43519, 43519), + (43575, 43583), + (43598, 43599), + (43610, 43611), + (43715, 43738), + (43767, 43776), + (43783, 43784), + (43791, 43792), + (43799, 43807), + (43815, 43815), + (43823, 43823), + (43884, 43887), + (44014, 44015), + (44026, 44031), + (55204, 55215), + (55239, 55242), + (55292, 55295), + (64110, 64111), + (64218, 64255), + (64263, 64274), + (64280, 64284), + (64311, 64311), + (64317, 64317), + (64319, 64319), + (64322, 64322), + (64325, 64325), + (64450, 64466), + (64832, 64847), + (64912, 64913), + (64968, 65007), + (65022, 65023), + (65050, 65055), + (65107, 65107), + (65127, 65127), + (65132, 65135), + (65141, 65141), + (65277, 65278), + (65280, 65280), + (65471, 65473), + (65480, 65481), + (65488, 65489), + (65496, 65497), + (65501, 65503), + (65511, 65511), + (65519, 65528), + (65534, 65535), + (65548, 65548), + (65575, 65575), + (65595, 65595), + (65598, 65598), + (65614, 65615), + (65630, 65663), + (65787, 65791), + (65795, 65798), + (65844, 65846), + (65935, 65935), + (65949, 65951), + (65953, 65999), + (66046, 66175), + (66205, 66207), + (66257, 66271), + (66300, 66303), + (66340, 66348), + (66379, 66383), + (66427, 66431), + (66462, 66462), + (66500, 66503), + (66518, 66559), + (66718, 66719), + (66730, 66735), + (66772, 66775), + (66812, 66815), + (66856, 66863), + (66916, 66926), + (66928, 67071), + (67383, 67391), + (67414, 67423), + (67432, 67583), + (67590, 67591), + (67593, 67593), + (67638, 67638), + (67641, 67643), + (67645, 67646), + (67670, 67670), + (67743, 67750), + (67760, 67807), + (67827, 67827), + (67830, 67834), + (67868, 67870), + (67898, 67902), + (67904, 67967), + (68024, 68027), + (68048, 68049), + (68100, 68100), + (68103, 68107), + (68116, 68116), + (68120, 68120), + (68150, 68151), + (68155, 68158), + (68169, 68175), + (68185, 68191), + (68256, 68287), + (68327, 68330), + (68343, 68351), + (68406, 68408), + (68438, 68439), + (68467, 68471), + (68498, 68504), + (68509, 68520), + (68528, 68607), + (68681, 68735), + (68787, 68799), + (68851, 68857), + (68904, 68911), + (68922, 69215), + (69247, 69247), + (69290, 69290), + (69294, 69295), + (69298, 69375), + (69416, 69423), + (69466, 69551), + (69580, 69599), + (69623, 69631), + (69710, 69713), + (69744, 69758), + (69826, 69836), + (69838, 69839), + (69865, 69871), + (69882, 69887), + (69941, 69941), + (69960, 69967), + (70007, 70015), + (70112, 70112), + (70133, 70143), + (70162, 70162), + (70207, 70271), + (70279, 70279), + (70281, 70281), + (70286, 70286), + (70302, 70302), + (70314, 70319), + (70379, 70383), + (70394, 70399), + (70404, 70404), + (70413, 70414), + (70417, 70418), + (70441, 70441), + (70449, 70449), + (70452, 70452), + (70458, 70458), + (70469, 70470), + (70473, 70474), + (70478, 70479), + (70481, 70486), + (70488, 70492), + (70500, 70501), + (70509, 70511), + (70517, 70655), + (70748, 70748), + (70754, 70783), + (70856, 70863), + (70874, 71039), + (71094, 71095), + (71134, 71167), + (71237, 71247), + (71258, 71263), + (71277, 71295), + (71353, 71359), + (71370, 71423), + (71451, 71452), + (71468, 71471), + (71488, 71679), + (71740, 71839), + (71923, 71934), + (71943, 71944), + (71946, 71947), + (71956, 71956), + (71959, 71959), + (71990, 71990), + (71993, 71994), + (72007, 72015), + (72026, 72095), + (72104, 72105), + (72152, 72153), + (72165, 72191), + (72264, 72271), + (72355, 72383), + (72441, 72703), + (72713, 72713), + (72759, 72759), + (72774, 72783), + (72813, 72815), + (72848, 72849), + (72872, 72872), + (72887, 72959), + (72967, 72967), + (72970, 72970), + (73015, 73017), + (73019, 73019), + (73022, 73022), + (73032, 73039), + (73050, 73055), + (73062, 73062), + (73065, 73065), + (73103, 73103), + (73106, 73106), + (73113, 73119), + (73130, 73439), + (73465, 73647), + (73649, 73663), + (73714, 73726), + (74650, 74751), + (74863, 74863), + (74869, 74879), + (75076, 77823), + (78895, 78895), + (78905, 82943), + (83527, 92159), + (92729, 92735), + (92767, 92767), + (92778, 92781), + (92784, 92879), + (92910, 92911), + (92918, 92927), + (92998, 93007), + (93018, 93018), + (93026, 93026), + (93048, 93052), + (93072, 93759), + (93851, 93951), + (94027, 94030), + (94088, 94094), + (94112, 94175), + (94181, 94191), + (94194, 94207), + (100344, 100351), + (101590, 101631), + (101641, 110591), + (110879, 110927), + (110931, 110947), + (110952, 110959), + (111356, 113663), + (113771, 113775), + (113789, 113791), + (113801, 113807), + (113818, 113819), + (113828, 118783), + (119030, 119039), + (119079, 119080), + (119273, 119295), + (119366, 119519), + (119540, 119551), + (119639, 119647), + (119673, 119807), + (119893, 119893), + (119965, 119965), + (119968, 119969), + (119971, 119972), + (119975, 119976), + (119981, 119981), + (119994, 119994), + (119996, 119996), + (120004, 120004), + (120070, 120070), + (120075, 120076), + (120085, 120085), + (120093, 120093), + (120122, 120122), + (120127, 120127), + (120133, 120133), + (120135, 120137), + (120145, 120145), + (120486, 120487), + (120780, 120781), + (121484, 121498), + (121504, 121504), + (121520, 122879), + (122887, 122887), + (122905, 122906), + (122914, 122914), + (122917, 122917), + (122923, 123135), + (123181, 123183), + (123198, 123199), + (123210, 123213), + (123216, 123583), + (123642, 123646), + (123648, 124927), + (125125, 125126), + (125143, 125183), + (125260, 125263), + (125274, 125277), + (125280, 126064), + (126133, 126208), + (126270, 126463), + (126468, 126468), + (126496, 126496), + (126499, 126499), + (126501, 126502), + (126504, 126504), + (126515, 126515), + (126520, 126520), + (126522, 126522), + (126524, 126529), + (126531, 126534), + (126536, 126536), + (126538, 126538), + (126540, 126540), + (126544, 126544), + (126547, 126547), + (126549, 126550), + (126552, 126552), + (126554, 126554), + (126556, 126556), + (126558, 126558), + (126560, 126560), + (126563, 126563), + (126565, 126566), + (126571, 126571), + (126579, 126579), + (126584, 126584), + (126589, 126589), + (126591, 126591), + (126602, 126602), + (126620, 126624), + (126628, 126628), + (126634, 126634), + (126652, 126703), + (126706, 126975), + (127020, 127023), + (127124, 127135), + (127151, 127152), + (127168, 127168), + (127184, 127184), + (127222, 127231), + (127406, 127461), + (127491, 127503), + (127548, 127551), + (127561, 127567), + (127570, 127583), + (127590, 127743), + (128728, 128735), + (128749, 128751), + (128765, 128767), + (128884, 128895), + (128985, 128991), + (129004, 129023), + (129036, 129039), + (129096, 129103), + (129114, 129119), + (129160, 129167), + (129198, 129199), + (129202, 129279), + (129401, 129401), + (129484, 129484), + (129620, 129631), + (129646, 129647), + (129653, 129655), + (129659, 129663), + (129671, 129679), + (129705, 129711), + (129719, 129727), + (129731, 129743), + (129751, 129791), + (129939, 129939), + (129995, 130031), + (130042, 131071), + (173790, 173823), + (177973, 177983), + (178206, 178207), + (183970, 183983), + (191457, 194559), + (195102, 196607), + (201547, 917504), + (917506, 917535), + (917632, 917759), + (918000, 983039), + (1048574, 1048575), + (1114110, 1114111), +]; + +pub const UPPERCASE_LETTER: &'static [(u32, u32)] = &[ + (65, 90), + (192, 214), + (216, 222), + (256, 256), + (258, 258), + (260, 260), + (262, 262), + (264, 264), + (266, 266), + (268, 268), + (270, 270), + (272, 272), + (274, 274), + (276, 276), + (278, 278), + (280, 280), + (282, 282), + (284, 284), + (286, 286), + (288, 288), + (290, 290), + (292, 292), + (294, 294), + (296, 296), + (298, 298), + (300, 300), + (302, 302), + (304, 304), + (306, 306), + (308, 308), + (310, 310), + (313, 313), + (315, 315), + (317, 317), + (319, 319), + (321, 321), + (323, 323), + (325, 325), + (327, 327), + (330, 330), + (332, 332), + (334, 334), + (336, 336), + (338, 338), + (340, 340), + (342, 342), + (344, 344), + (346, 346), + (348, 348), + (350, 350), + (352, 352), + (354, 354), + (356, 356), + (358, 358), + (360, 360), + (362, 362), + (364, 364), + (366, 366), + (368, 368), + (370, 370), + (372, 372), + (374, 374), + (376, 377), + (379, 379), + (381, 381), + (385, 386), + (388, 388), + (390, 391), + (393, 395), + (398, 401), + (403, 404), + (406, 408), + (412, 413), + (415, 416), + (418, 418), + (420, 420), + (422, 423), + (425, 425), + (428, 428), + (430, 431), + (433, 435), + (437, 437), + (439, 440), + (444, 444), + (452, 452), + (455, 455), + (458, 458), + (461, 461), + (463, 463), + (465, 465), + (467, 467), + (469, 469), + (471, 471), + (473, 473), + (475, 475), + (478, 478), + (480, 480), + (482, 482), + (484, 484), + (486, 486), + (488, 488), + (490, 490), + (492, 492), + (494, 494), + (497, 497), + (500, 500), + (502, 504), + (506, 506), + (508, 508), + (510, 510), + (512, 512), + (514, 514), + (516, 516), + (518, 518), + (520, 520), + (522, 522), + (524, 524), + (526, 526), + (528, 528), + (530, 530), + (532, 532), + (534, 534), + (536, 536), + (538, 538), + (540, 540), + (542, 542), + (544, 544), + (546, 546), + (548, 548), + (550, 550), + (552, 552), + (554, 554), + (556, 556), + (558, 558), + (560, 560), + (562, 562), + (570, 571), + (573, 574), + (577, 577), + (579, 582), + (584, 584), + (586, 586), + (588, 588), + (590, 590), + (880, 880), + (882, 882), + (886, 886), + (895, 895), + (902, 902), + (904, 906), + (908, 908), + (910, 911), + (913, 929), + (931, 939), + (975, 975), + (978, 980), + (984, 984), + (986, 986), + (988, 988), + (990, 990), + (992, 992), + (994, 994), + (996, 996), + (998, 998), + (1000, 1000), + (1002, 1002), + (1004, 1004), + (1006, 1006), + (1012, 1012), + (1015, 1015), + (1017, 1018), + (1021, 1071), + (1120, 1120), + (1122, 1122), + (1124, 1124), + (1126, 1126), + (1128, 1128), + (1130, 1130), + (1132, 1132), + (1134, 1134), + (1136, 1136), + (1138, 1138), + (1140, 1140), + (1142, 1142), + (1144, 1144), + (1146, 1146), + (1148, 1148), + (1150, 1150), + (1152, 1152), + (1162, 1162), + (1164, 1164), + (1166, 1166), + (1168, 1168), + (1170, 1170), + (1172, 1172), + (1174, 1174), + (1176, 1176), + (1178, 1178), + (1180, 1180), + (1182, 1182), + (1184, 1184), + (1186, 1186), + (1188, 1188), + (1190, 1190), + (1192, 1192), + (1194, 1194), + (1196, 1196), + (1198, 1198), + (1200, 1200), + (1202, 1202), + (1204, 1204), + (1206, 1206), + (1208, 1208), + (1210, 1210), + (1212, 1212), + (1214, 1214), + (1216, 1217), + (1219, 1219), + (1221, 1221), + (1223, 1223), + (1225, 1225), + (1227, 1227), + (1229, 1229), + (1232, 1232), + (1234, 1234), + (1236, 1236), + (1238, 1238), + (1240, 1240), + (1242, 1242), + (1244, 1244), + (1246, 1246), + (1248, 1248), + (1250, 1250), + (1252, 1252), + (1254, 1254), + (1256, 1256), + (1258, 1258), + (1260, 1260), + (1262, 1262), + (1264, 1264), + (1266, 1266), + (1268, 1268), + (1270, 1270), + (1272, 1272), + (1274, 1274), + (1276, 1276), + (1278, 1278), + (1280, 1280), + (1282, 1282), + (1284, 1284), + (1286, 1286), + (1288, 1288), + (1290, 1290), + (1292, 1292), + (1294, 1294), + (1296, 1296), + (1298, 1298), + (1300, 1300), + (1302, 1302), + (1304, 1304), + (1306, 1306), + (1308, 1308), + (1310, 1310), + (1312, 1312), + (1314, 1314), + (1316, 1316), + (1318, 1318), + (1320, 1320), + (1322, 1322), + (1324, 1324), + (1326, 1326), + (1329, 1366), + (4256, 4293), + (4295, 4295), + (4301, 4301), + (5024, 5109), + (7312, 7354), + (7357, 7359), + (7680, 7680), + (7682, 7682), + (7684, 7684), + (7686, 7686), + (7688, 7688), + (7690, 7690), + (7692, 7692), + (7694, 7694), + (7696, 7696), + (7698, 7698), + (7700, 7700), + (7702, 7702), + (7704, 7704), + (7706, 7706), + (7708, 7708), + (7710, 7710), + (7712, 7712), + (7714, 7714), + (7716, 7716), + (7718, 7718), + (7720, 7720), + (7722, 7722), + (7724, 7724), + (7726, 7726), + (7728, 7728), + (7730, 7730), + (7732, 7732), + (7734, 7734), + (7736, 7736), + (7738, 7738), + (7740, 7740), + (7742, 7742), + (7744, 7744), + (7746, 7746), + (7748, 7748), + (7750, 7750), + (7752, 7752), + (7754, 7754), + (7756, 7756), + (7758, 7758), + (7760, 7760), + (7762, 7762), + (7764, 7764), + (7766, 7766), + (7768, 7768), + (7770, 7770), + (7772, 7772), + (7774, 7774), + (7776, 7776), + (7778, 7778), + (7780, 7780), + (7782, 7782), + (7784, 7784), + (7786, 7786), + (7788, 7788), + (7790, 7790), + (7792, 7792), + (7794, 7794), + (7796, 7796), + (7798, 7798), + (7800, 7800), + (7802, 7802), + (7804, 7804), + (7806, 7806), + (7808, 7808), + (7810, 7810), + (7812, 7812), + (7814, 7814), + (7816, 7816), + (7818, 7818), + (7820, 7820), + (7822, 7822), + (7824, 7824), + (7826, 7826), + (7828, 7828), + (7838, 7838), + (7840, 7840), + (7842, 7842), + (7844, 7844), + (7846, 7846), + (7848, 7848), + (7850, 7850), + (7852, 7852), + (7854, 7854), + (7856, 7856), + (7858, 7858), + (7860, 7860), + (7862, 7862), + (7864, 7864), + (7866, 7866), + (7868, 7868), + (7870, 7870), + (7872, 7872), + (7874, 7874), + (7876, 7876), + (7878, 7878), + (7880, 7880), + (7882, 7882), + (7884, 7884), + (7886, 7886), + (7888, 7888), + (7890, 7890), + (7892, 7892), + (7894, 7894), + (7896, 7896), + (7898, 7898), + (7900, 7900), + (7902, 7902), + (7904, 7904), + (7906, 7906), + (7908, 7908), + (7910, 7910), + (7912, 7912), + (7914, 7914), + (7916, 7916), + (7918, 7918), + (7920, 7920), + (7922, 7922), + (7924, 7924), + (7926, 7926), + (7928, 7928), + (7930, 7930), + (7932, 7932), + (7934, 7934), + (7944, 7951), + (7960, 7965), + (7976, 7983), + (7992, 7999), + (8008, 8013), + (8025, 8025), + (8027, 8027), + (8029, 8029), + (8031, 8031), + (8040, 8047), + (8120, 8123), + (8136, 8139), + (8152, 8155), + (8168, 8172), + (8184, 8187), + (8450, 8450), + (8455, 8455), + (8459, 8461), + (8464, 8466), + (8469, 8469), + (8473, 8477), + (8484, 8484), + (8486, 8486), + (8488, 8488), + (8490, 8493), + (8496, 8499), + (8510, 8511), + (8517, 8517), + (8579, 8579), + (11264, 11310), + (11360, 11360), + (11362, 11364), + (11367, 11367), + (11369, 11369), + (11371, 11371), + (11373, 11376), + (11378, 11378), + (11381, 11381), + (11390, 11392), + (11394, 11394), + (11396, 11396), + (11398, 11398), + (11400, 11400), + (11402, 11402), + (11404, 11404), + (11406, 11406), + (11408, 11408), + (11410, 11410), + (11412, 11412), + (11414, 11414), + (11416, 11416), + (11418, 11418), + (11420, 11420), + (11422, 11422), + (11424, 11424), + (11426, 11426), + (11428, 11428), + (11430, 11430), + (11432, 11432), + (11434, 11434), + (11436, 11436), + (11438, 11438), + (11440, 11440), + (11442, 11442), + (11444, 11444), + (11446, 11446), + (11448, 11448), + (11450, 11450), + (11452, 11452), + (11454, 11454), + (11456, 11456), + (11458, 11458), + (11460, 11460), + (11462, 11462), + (11464, 11464), + (11466, 11466), + (11468, 11468), + (11470, 11470), + (11472, 11472), + (11474, 11474), + (11476, 11476), + (11478, 11478), + (11480, 11480), + (11482, 11482), + (11484, 11484), + (11486, 11486), + (11488, 11488), + (11490, 11490), + (11499, 11499), + (11501, 11501), + (11506, 11506), + (42560, 42560), + (42562, 42562), + (42564, 42564), + (42566, 42566), + (42568, 42568), + (42570, 42570), + (42572, 42572), + (42574, 42574), + (42576, 42576), + (42578, 42578), + (42580, 42580), + (42582, 42582), + (42584, 42584), + (42586, 42586), + (42588, 42588), + (42590, 42590), + (42592, 42592), + (42594, 42594), + (42596, 42596), + (42598, 42598), + (42600, 42600), + (42602, 42602), + (42604, 42604), + (42624, 42624), + (42626, 42626), + (42628, 42628), + (42630, 42630), + (42632, 42632), + (42634, 42634), + (42636, 42636), + (42638, 42638), + (42640, 42640), + (42642, 42642), + (42644, 42644), + (42646, 42646), + (42648, 42648), + (42650, 42650), + (42786, 42786), + (42788, 42788), + (42790, 42790), + (42792, 42792), + (42794, 42794), + (42796, 42796), + (42798, 42798), + (42802, 42802), + (42804, 42804), + (42806, 42806), + (42808, 42808), + (42810, 42810), + (42812, 42812), + (42814, 42814), + (42816, 42816), + (42818, 42818), + (42820, 42820), + (42822, 42822), + (42824, 42824), + (42826, 42826), + (42828, 42828), + (42830, 42830), + (42832, 42832), + (42834, 42834), + (42836, 42836), + (42838, 42838), + (42840, 42840), + (42842, 42842), + (42844, 42844), + (42846, 42846), + (42848, 42848), + (42850, 42850), + (42852, 42852), + (42854, 42854), + (42856, 42856), + (42858, 42858), + (42860, 42860), + (42862, 42862), + (42873, 42873), + (42875, 42875), + (42877, 42878), + (42880, 42880), + (42882, 42882), + (42884, 42884), + (42886, 42886), + (42891, 42891), + (42893, 42893), + (42896, 42896), + (42898, 42898), + (42902, 42902), + (42904, 42904), + (42906, 42906), + (42908, 42908), + (42910, 42910), + (42912, 42912), + (42914, 42914), + (42916, 42916), + (42918, 42918), + (42920, 42920), + (42922, 42926), + (42928, 42932), + (42934, 42934), + (42936, 42936), + (42938, 42938), + (42940, 42940), + (42942, 42942), + (42946, 42946), + (42948, 42951), + (42953, 42953), + (42997, 42997), + (65313, 65338), + (66560, 66599), + (66736, 66771), + (68736, 68786), + (71840, 71871), + (93760, 93791), + (119808, 119833), + (119860, 119885), + (119912, 119937), + (119964, 119964), + (119966, 119967), + (119970, 119970), + (119973, 119974), + (119977, 119980), + (119982, 119989), + (120016, 120041), + (120068, 120069), + (120071, 120074), + (120077, 120084), + (120086, 120092), + (120120, 120121), + (120123, 120126), + (120128, 120132), + (120134, 120134), + (120138, 120144), + (120172, 120197), + (120224, 120249), + (120276, 120301), + (120328, 120353), + (120380, 120405), + (120432, 120457), + (120488, 120512), + (120546, 120570), + (120604, 120628), + (120662, 120686), + (120720, 120744), + (120778, 120778), + (125184, 125217), +]; diff --git a/vendor/ucd-trie/src/lib.rs b/vendor/ucd-trie/src/lib.rs new file mode 100644 index 000000000..2c921d53b --- /dev/null +++ b/vendor/ucd-trie/src/lib.rs @@ -0,0 +1,117 @@ +/*! +The ucd-trie crate provides a compressed trie set specifically tailored for +Unicode codepoints. The principle use case for such a trie is to represent +properties defined by Unicode that correspond to sets of Unicode codepoints. +(These properties are formally called boolean properties or "single valued" +properties. See +[UTR#23 S3.3](http://www.unicode.org/reports/tr23/#PropertyTypeDefinitions) +for more details.) + +This crate has two principle types: `TrieSetOwned` and `TrieSetSlice`, +corresponding to a similar split as there is between `Vec` and `&[T]`. +`TrieSetOwned` is the only way to construct a trie from a set of Unicode +codepoints. + +The intended use of this library is to embed a static instance of +`TrieSetSlice` into your source code, and then use its methods as defined in +this crate to test membership. (The `ucd-generate` tool can likely generate +this code for you.) + +Finally, while this crate uses the standard library by default, it provides +`no_std` functionality by disabling the `std` feature. When `no_std` is +enabled, then `TrieSetOwned` is not provided. Instead, only `TrieSetSlice` is +provided, which means `no_std` crates can still embed tries into their code. +*/ + +#![deny(missing_docs)] +#![cfg_attr(not(feature = "std"), no_std)] + +use core::fmt; + +#[cfg(feature = "std")] +pub use crate::owned::{Error, Result, TrieSetOwned}; + +#[cfg(test)] +#[allow(dead_code)] +mod general_category; +#[cfg(feature = "std")] +mod owned; + +const CHUNK_SIZE: usize = 64; + +/// A type alias for `TrieSetSlice<'static>`. +pub type TrieSet = TrieSetSlice<'static>; + +/// A borrowed trie set. +#[derive(Clone, Copy)] +pub struct TrieSetSlice<'a> { + /// first tree, one level + #[doc(hidden)] + pub tree1_level1: &'a [u64], + /// second tree, first level + #[doc(hidden)] + pub tree2_level1: &'a [u8], + /// second tree, second level + #[doc(hidden)] + pub tree2_level2: &'a [u64], + /// third tree, first level + #[doc(hidden)] + pub tree3_level1: &'a [u8], + /// third tree, second level + #[doc(hidden)] + pub tree3_level2: &'a [u8], + /// third tree, third level + #[doc(hidden)] + pub tree3_level3: &'a [u64], +} + +impl<'a> fmt::Debug for TrieSetSlice<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "TrieSetSlice(...)") + } +} + +impl<'a> TrieSetSlice<'a> { + /// Returns true if and only if the given Unicode scalar value is in this + /// set. + pub fn contains_char(&self, c: char) -> bool { + self.contains(c as usize) + } + + /// Returns true if and only if the given codepoint is in this set. + /// + /// If the given value exceeds the codepoint range (i.e., it's greater + /// than `0x10FFFF`), then this returns false. + pub fn contains_u32(&self, cp: u32) -> bool { + if cp > 0x10FFFF { + return false; + } + self.contains(cp as usize) + } + + #[inline(always)] + fn contains(&self, cp: usize) -> bool { + if cp < 0x800 { + self.chunk_contains(cp, self.tree1_level1[cp >> 6]) + } else if cp < 0x10000 { + let leaf = match self.tree2_level1.get((cp >> 6) - 0x20) { + None => return false, + Some(&leaf) => leaf, + }; + self.chunk_contains(cp, self.tree2_level2[leaf as usize]) + } else { + let child = match self.tree3_level1.get((cp >> 12) - 0x10) { + None => return false, + Some(&child) => child, + }; + let i = ((child as usize) * CHUNK_SIZE) + ((cp >> 6) & 0b111111); + let leaf = self.tree3_level2[i]; + self.chunk_contains(cp, self.tree3_level3[leaf as usize]) + } + } + + #[inline(always)] + fn chunk_contains(&self, cp: usize, chunk: u64) -> bool { + ((chunk >> (cp & 0b111111)) & 1) == 1 + } +} diff --git a/vendor/ucd-trie/src/owned.rs b/vendor/ucd-trie/src/owned.rs new file mode 100644 index 000000000..a6213784e --- /dev/null +++ b/vendor/ucd-trie/src/owned.rs @@ -0,0 +1,371 @@ +use std::borrow::Borrow; +use std::collections::HashMap; +use std::error; +use std::fmt; +use std::io; +use std::result; + +use super::{TrieSetSlice, CHUNK_SIZE}; + +// This implementation was pretty much cribbed from raphlinus' contribution +// to the standard library: https://github.com/rust-lang/rust/pull/33098/files +// +// The fundamental principle guiding this implementation is to take advantage +// of the fact that similar Unicode codepoints are often grouped together, and +// that most boolean Unicode properties are quite sparse over the entire space +// of Unicode codepoints. +// +// To do this, we represent sets using something like a trie (which gives us +// prefix compression). The "final" states of the trie are embedded in leaves +// or "chunks," where each chunk is a 64 bit integer. Each bit position of the +// integer corresponds to whether a particular codepoint is in the set or not. +// These chunks are not just a compact representation of the final states of +// the trie, but are also a form of suffix compression. In particular, if +// multiple ranges of 64 contiguous codepoints map have the same set membership +// ordering, then they all map to the exact same chunk in the trie. +// +// We organize this structure by partitioning the space of Unicode codepoints +// into three disjoint sets. The first set corresponds to codepoints +// [0, 0x800), the second [0x800, 0x1000) and the third [0x10000, 0x110000). +// These partitions conveniently correspond to the space of 1 or 2 byte UTF-8 +// encoded codepoints, 3 byte UTF-8 encoded codepoints and 4 byte UTF-8 encoded +// codepoints, respectively. +// +// Each partition has its own tree with its own root. The first partition is +// the simplest, since the tree is completely flat. In particular, to determine +// the set membership of a Unicode codepoint (that is less than `0x800`), we +// do the following (where `cp` is the codepoint we're testing): +// +// let chunk_address = cp >> 6; +// let chunk_bit = cp & 0b111111; +// let chunk = tree1[cp >> 6]; +// let is_member = 1 == ((chunk >> chunk_bit) & 1); +// +// We do something similar for the second partition: +// +// // we subtract 0x20 since (0x800 >> 6) == 0x20. +// let child_address = (cp >> 6) - 0x20; +// let chunk_address = tree2_level1[child_address]; +// let chunk_bit = cp & 0b111111; +// let chunk = tree2_level2[chunk_address]; +// let is_member = 1 == ((chunk >> chunk_bit) & 1); +// +// And so on for the third partition. +// +// Note that as a special case, if the second or third partitions are empty, +// then the trie will store empty slices for those levels. The `contains` +// check knows to return `false` in those cases. + +const CHUNKS: usize = 0x110000 / CHUNK_SIZE; + +/// A type alias that maps to `std::result::Result`. +pub type Result = result::Result; + +/// An error that can occur during construction of a trie. +#[derive(Clone, Debug)] +pub enum Error { + /// This error is returned when an invalid codepoint is given to + /// `TrieSetOwned::from_codepoints`. An invalid codepoint is a `u32` that + /// is greater than `0x10FFFF`. + InvalidCodepoint(u32), + /// This error is returned when a set of Unicode codepoints could not be + /// sufficiently compressed into the trie provided by this crate. There is + /// no work-around for this error at this time. + GaveUp, +} + +impl error::Error for Error {} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Error::InvalidCodepoint(cp) => write!( + f, + "could not construct trie set containing an \ + invalid Unicode codepoint: 0x{:X}", + cp + ), + Error::GaveUp => { + write!(f, "could not compress codepoint set into a trie") + } + } + } +} + +impl From for io::Error { + fn from(err: Error) -> io::Error { + io::Error::new(io::ErrorKind::Other, err) + } +} + +/// An owned trie set. +#[derive(Clone)] +pub struct TrieSetOwned { + tree1_level1: Vec, + tree2_level1: Vec, + tree2_level2: Vec, + tree3_level1: Vec, + tree3_level2: Vec, + tree3_level3: Vec, +} + +impl fmt::Debug for TrieSetOwned { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "TrieSetOwned(...)") + } +} + +impl TrieSetOwned { + fn new(all: &[bool]) -> Result { + let mut bitvectors = Vec::with_capacity(CHUNKS); + for i in 0..CHUNKS { + let mut bitvector = 0u64; + for j in 0..CHUNK_SIZE { + if all[i * CHUNK_SIZE + j] { + bitvector |= 1 << j; + } + } + bitvectors.push(bitvector); + } + + let tree1_level1 = + bitvectors.iter().cloned().take(0x800 / CHUNK_SIZE).collect(); + + let (mut tree2_level1, mut tree2_level2) = compress_postfix_leaves( + &bitvectors[0x800 / CHUNK_SIZE..0x10000 / CHUNK_SIZE], + )?; + if tree2_level2.len() == 1 && tree2_level2[0] == 0 { + tree2_level1.clear(); + tree2_level2.clear(); + } + + let (mid, mut tree3_level3) = compress_postfix_leaves( + &bitvectors[0x10000 / CHUNK_SIZE..0x110000 / CHUNK_SIZE], + )?; + let (mut tree3_level1, mut tree3_level2) = + compress_postfix_mid(&mid, 64)?; + if tree3_level3.len() == 1 && tree3_level3[0] == 0 { + tree3_level1.clear(); + tree3_level2.clear(); + tree3_level3.clear(); + } + + Ok(TrieSetOwned { + tree1_level1, + tree2_level1, + tree2_level2, + tree3_level1, + tree3_level2, + tree3_level3, + }) + } + + /// Create a new trie set from a set of Unicode scalar values. + /// + /// This returns an error if a set could not be sufficiently compressed to + /// fit into a trie. + pub fn from_scalars(scalars: I) -> Result + where + I: IntoIterator, + C: Borrow, + { + let mut all = vec![false; 0x110000]; + for s in scalars { + all[*s.borrow() as usize] = true; + } + TrieSetOwned::new(&all) + } + + /// Create a new trie set from a set of Unicode scalar values. + /// + /// This returns an error if a set could not be sufficiently compressed to + /// fit into a trie. This also returns an error if any of the given + /// codepoints are greater than `0x10FFFF`. + pub fn from_codepoints(codepoints: I) -> Result + where + I: IntoIterator, + C: Borrow, + { + let mut all = vec![false; 0x110000]; + for cp in codepoints { + let cp = *cp.borrow(); + if cp > 0x10FFFF { + return Err(Error::InvalidCodepoint(cp)); + } + all[cp as usize] = true; + } + TrieSetOwned::new(&all) + } + + /// Return this set as a slice. + #[inline(always)] + pub fn as_slice(&self) -> TrieSetSlice<'_> { + TrieSetSlice { + tree1_level1: &self.tree1_level1, + tree2_level1: &self.tree2_level1, + tree2_level2: &self.tree2_level2, + tree3_level1: &self.tree3_level1, + tree3_level2: &self.tree3_level2, + tree3_level3: &self.tree3_level3, + } + } + + /// Returns true if and only if the given Unicode scalar value is in this + /// set. + pub fn contains_char(&self, c: char) -> bool { + self.as_slice().contains_char(c) + } + + /// Returns true if and only if the given codepoint is in this set. + /// + /// If the given value exceeds the codepoint range (i.e., it's greater + /// than `0x10FFFF`), then this returns false. + pub fn contains_u32(&self, cp: u32) -> bool { + self.as_slice().contains_u32(cp) + } +} + +fn compress_postfix_leaves(chunks: &[u64]) -> Result<(Vec, Vec)> { + let mut root = vec![]; + let mut children = vec![]; + let mut bychild = HashMap::new(); + for &chunk in chunks { + if !bychild.contains_key(&chunk) { + let start = bychild.len(); + if start > ::std::u8::MAX as usize { + return Err(Error::GaveUp); + } + bychild.insert(chunk, start as u8); + children.push(chunk); + } + root.push(bychild[&chunk]); + } + Ok((root, children)) +} + +fn compress_postfix_mid( + chunks: &[u8], + chunk_size: usize, +) -> Result<(Vec, Vec)> { + let mut root = vec![]; + let mut children = vec![]; + let mut bychild = HashMap::new(); + for i in 0..(chunks.len() / chunk_size) { + let chunk = &chunks[i * chunk_size..(i + 1) * chunk_size]; + if !bychild.contains_key(chunk) { + let start = bychild.len(); + if start > ::std::u8::MAX as usize { + return Err(Error::GaveUp); + } + bychild.insert(chunk, start as u8); + children.extend(chunk); + } + root.push(bychild[chunk]); + } + Ok((root, children)) +} + +#[cfg(test)] +mod tests { + use super::TrieSetOwned; + use crate::general_category; + use std::collections::HashSet; + + fn mk(scalars: &[char]) -> TrieSetOwned { + TrieSetOwned::from_scalars(scalars).unwrap() + } + + fn ranges_to_set(ranges: &[(u32, u32)]) -> Vec { + let mut set = vec![]; + for &(start, end) in ranges { + for cp in start..end + 1 { + set.push(cp); + } + } + set + } + + #[test] + fn set1() { + let set = mk(&['a']); + assert!(set.contains_char('a')); + assert!(!set.contains_char('b')); + assert!(!set.contains_char('β')); + assert!(!set.contains_char('☃')); + assert!(!set.contains_char('😼')); + } + + #[test] + fn set_combined() { + let set = mk(&['a', 'b', 'β', '☃', '😼']); + assert!(set.contains_char('a')); + assert!(set.contains_char('b')); + assert!(set.contains_char('β')); + assert!(set.contains_char('☃')); + assert!(set.contains_char('😼')); + + assert!(!set.contains_char('c')); + assert!(!set.contains_char('θ')); + assert!(!set.contains_char('⛇')); + assert!(!set.contains_char('🐲')); + } + + // Basic tests on all of the general category sets. We check that + // membership is correct on every Unicode codepoint... because we can. + + macro_rules! category_test { + ($name:ident, $ranges:ident) => { + #[test] + fn $name() { + let set = ranges_to_set(general_category::$ranges); + let hashset: HashSet = set.iter().cloned().collect(); + let trie = TrieSetOwned::from_codepoints(&set).unwrap(); + for cp in 0..0x110000 { + assert!(trie.contains_u32(cp) == hashset.contains(&cp)); + } + // Test that an invalid codepoint is treated correctly. + assert!(!trie.contains_u32(0x110000)); + assert!(!hashset.contains(&0x110000)); + } + }; + } + + category_test!(gencat_cased_letter, CASED_LETTER); + category_test!(gencat_close_punctuation, CLOSE_PUNCTUATION); + category_test!(gencat_connector_punctuation, CONNECTOR_PUNCTUATION); + category_test!(gencat_control, CONTROL); + category_test!(gencat_currency_symbol, CURRENCY_SYMBOL); + category_test!(gencat_dash_punctuation, DASH_PUNCTUATION); + category_test!(gencat_decimal_number, DECIMAL_NUMBER); + category_test!(gencat_enclosing_mark, ENCLOSING_MARK); + category_test!(gencat_final_punctuation, FINAL_PUNCTUATION); + category_test!(gencat_format, FORMAT); + category_test!(gencat_initial_punctuation, INITIAL_PUNCTUATION); + category_test!(gencat_letter, LETTER); + category_test!(gencat_letter_number, LETTER_NUMBER); + category_test!(gencat_line_separator, LINE_SEPARATOR); + category_test!(gencat_lowercase_letter, LOWERCASE_LETTER); + category_test!(gencat_math_symbol, MATH_SYMBOL); + category_test!(gencat_mark, MARK); + category_test!(gencat_modifier_letter, MODIFIER_LETTER); + category_test!(gencat_modifier_symbol, MODIFIER_SYMBOL); + category_test!(gencat_nonspacing_mark, NONSPACING_MARK); + category_test!(gencat_number, NUMBER); + category_test!(gencat_open_punctuation, OPEN_PUNCTUATION); + category_test!(gencat_other, OTHER); + category_test!(gencat_other_letter, OTHER_LETTER); + category_test!(gencat_other_number, OTHER_NUMBER); + category_test!(gencat_other_punctuation, OTHER_PUNCTUATION); + category_test!(gencat_other_symbol, OTHER_SYMBOL); + category_test!(gencat_paragraph_separator, PARAGRAPH_SEPARATOR); + category_test!(gencat_private_use, PRIVATE_USE); + category_test!(gencat_punctuation, PUNCTUATION); + category_test!(gencat_separator, SEPARATOR); + category_test!(gencat_space_separator, SPACE_SEPARATOR); + category_test!(gencat_spacing_mark, SPACING_MARK); + category_test!(gencat_surrogate, SURROGATE); + category_test!(gencat_symbol, SYMBOL); + category_test!(gencat_titlecase_letter, TITLECASE_LETTER); + category_test!(gencat_unassigned, UNASSIGNED); + category_test!(gencat_uppercase_letter, UPPERCASE_LETTER); +} -- cgit v1.2.3