diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
commit | 698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch) | |
tree | 173a775858bd501c378080a10dca74132f05bc50 /vendor/pest | |
parent | Initial commit. (diff) | |
download | rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip |
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
67 files changed, 22897 insertions, 0 deletions
diff --git a/vendor/pest/.cargo-checksum.json b/vendor/pest/.cargo-checksum.json new file mode 100644 index 000000000..e086f365c --- /dev/null +++ b/vendor/pest/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.lock":"dc22ac85e4f2d9721c8353751fa5375423f0713c132bbfc65bff52fa86f8fa73","Cargo.toml":"6af58a5c349afda2efbe0ef44e6be51da5bf0f569867ef6438373040dd6cc94b","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","_README.md":"e9901b6c4d50403bfda7e08a92b5c395a8c51eba868c7bd07b03e00ccba702f3","examples/parens.rs":"24b83b7fc014813aa089fd05c3ee36926e215ce74a96b07b2c4033dad4ba15b2","src/error.rs":"40dfdd4d32fde69f5320fe9516abd3b4c92ce570a306a3a010c7328ebc542c98","src/iterators/flat_pairs.rs":"0b602eb86a8fd1c037ece03afbbabce316d5938da84f98ca027e8532c311c396","src/iterators/mod.rs":"dfb9cc6d6c0c96f7365ec69500128e3547c0b15dd4e85a5d36e125649244d57a","src/iterators/pair.rs":"510d52a9a6bdf23b20c3e5156028f92ef43e9d7ca88f526d493b5701105d92d5","src/iterators/pairs.rs":"4b8a0cf20ab10ee16d947cdcffbdea535a1d264ea6a1ec4836cb7f1baff2ca38","src/iterators/queueable_token.rs":"b6c4fd1d43437ea7c6cab45717c1fb66f71fc91aaf3ed9cf9f5686fd8ccfa8f9","src/iterators/tokens.rs":"4deea56d66805afe36afb229b9355b43db051b21836af4a88d1febcc4f762ff6","src/lib.rs":"fba1b443efda3f02f20f16094404a74000bc0c6534a80b20cf74f2314fe2a42c","src/macros.rs":"576dc3b66de8d17da494c4a353474fd9bb5ebcde9ffb0d5e9ce7e950ac5b5e7e","src/parser.rs":"2cb858fa80115bf65ff6ceedf3ad73b33fd112bab2a3db4f97be84d6aa4482b5","src/parser_state.rs":"6ba62636a4fefbd11dd92af4480b4ec03ce213ba3ef18136db84a0fb76abca69","src/position.rs":"1b28abf0c8cfefc0ed305c4072b27c4803946c2e5e0bc1d0a4d20ff70e9eb810","src/prec_climber.rs":"e56e8ef7e8e019b5277f164d44acda2d6b993979cc65457e37463204a462be1c","src/span.rs":"cc6ab623ea4c496ddac79d9f179937f47da7c08b514f917f1a3b4e16ca701f52","src/stack.rs":"4fe043bab74b30049c834132c6d8ffc5e21131bc58b7219c5026968013cd665f","src/token.rs":"4ee741dd833c06f8ae826226fb1e5eaa671732d1c68b6b79dea55856ab8b5a0a","src/unicode/binary.rs":"1dcc20ae3922e92fa753849086f8290bebd6d3a1440c2f3cb3482d2192136323","src/unicode/category.rs":"94923b31f349503958e32def13c0b682e52c08b528dd1e0853b55b17627e4ad6","src/unicode/mod.rs":"66a1525a031a7508bdbf65709829e96541d3cc4f228088107f1b94101beec8d6","tests/calculator.rs":"5787fa07560f3187d0a83042336c8613ca90d71186aea88b79ef2a2ccf06f7ab","tests/json.rs":"430913278a7ed16587ac2fcdab2c68329a96cd5d2d2b2eff01245852792e1af1"},"package":"10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"}
\ No newline at end of file diff --git a/vendor/pest/Cargo.lock b/vendor/pest/Cargo.lock new file mode 100644 index 000000000..a5501eddc --- /dev/null +++ b/vendor/pest/Cargo.lock @@ -0,0 +1,45 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "itoa" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8b7a7c0c47db5545ed3fef7468ee7bb5b74691498139e4b3f6a20685dc6dd8e" + +[[package]] +name = "pest" +version = "2.1.3" +dependencies = [ + "serde", + "serde_json", + "ucd-trie", +] + +[[package]] +name = "ryu" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa8506c1de11c9c4e4c38863ccbe02a305c8188e85a05a784c9e11e1c3910c8" + +[[package]] +name = "serde" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "414115f25f818d7dfccec8ee535d76949ae78584fc4f79a6f45a904bf8ab4449" + +[[package]] +name = "serde_json" +version = "1.0.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9371ade75d4c2d6cb154141b9752cf3781ec9c05e0e5cf35060e1e70ee7b9c25" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "ucd-trie" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f00ed7be0c1ff1e24f46c3d2af4859f7e863672ba3a6e92e7cff702bf9f06c2" diff --git a/vendor/pest/Cargo.toml b/vendor/pest/Cargo.toml new file mode 100644 index 000000000..5ad06075a --- /dev/null +++ b/vendor/pest/Cargo.toml @@ -0,0 +1,45 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "pest" +version = "2.1.3" +authors = ["Dragoș Tiselice <dragostiselice@gmail.com>"] +description = "The Elegant Parser" +homepage = "https://pest-parser.github.io/" +documentation = "https://docs.rs/pest" +readme = "_README.md" +keywords = ["pest", "parser", "peg", "grammar"] +categories = ["parsing"] +license = "MIT/Apache-2.0" +repository = "https://github.com/pest-parser/pest" +[dependencies.serde] +version = "1.0.89" +optional = true + +[dependencies.serde_json] +version = "1.0.39" +optional = true + +[dependencies.ucd-trie] +version = "0.1.1" + +[features] +pretty-print = ["serde", "serde_json"] +[badges.codecov] +repository = "pest-parser/pest" + +[badges.maintenance] +status = "actively-developed" + +[badges.travis-ci] +repository = "pest-parser/pest" diff --git a/vendor/pest/LICENSE-APACHE b/vendor/pest/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/vendor/pest/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/pest/LICENSE-MIT b/vendor/pest/LICENSE-MIT new file mode 100644 index 000000000..31aa79387 --- /dev/null +++ b/vendor/pest/LICENSE-MIT @@ -0,0 +1,23 @@ +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/pest/_README.md b/vendor/pest/_README.md new file mode 100644 index 000000000..8e55f29a2 --- /dev/null +++ b/vendor/pest/_README.md @@ -0,0 +1,169 @@ +<p align="center"> + <img src="https://raw.github.com/pest-parser/pest/master/pest-logo.svg?sanitize=true" width="80%"/> +</p> + +# pest. The Elegant Parser + +[![Join the chat at https://gitter.im/dragostis/pest](https://badges.gitter.im/dragostis/pest.svg)](https://gitter.im/dragostis/pest?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[![Book](https://img.shields.io/badge/book-WIP-4d76ae.svg)](https://pest-parser.github.io/book) +[![Docs](https://docs.rs/pest/badge.svg)](https://docs.rs/pest) + +[![Build Status](https://travis-ci.org/pest-parser/pest.svg?branch=master)](https://travis-ci.org/pest-parser/pest) +[![codecov](https://codecov.io/gh/pest-parser/pest/branch/master/graph/badge.svg)](https://codecov.io/gh/pest-parser/pest) +[![Fuzzit Status](https://app.fuzzit.dev/badge?org_id=pest-parser)](https://app.fuzzit.dev/orgs/pest-parser/dashboard) +[![Crates.io](https://img.shields.io/crates/d/pest.svg)](https://crates.io/crates/pest) +[![Crates.io](https://img.shields.io/crates/v/pest.svg)](https://crates.io/crates/pest) + +pest is a general purpose parser written in Rust with a focus on accessibility, +correctness, and performance. It uses parsing expression grammars +(or [PEG]) as input, which are similar in spirit to regular expressions, but +which offer the enhanced expressivity needed to parse complex languages. + +[PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar + +## Getting started + +The recommended way to start parsing with pest is to read the official [book]. + +Other helpful resources: + +* API reference on [docs.rs] +* play with grammars and share them on our [fiddle] +* leave feedback, ask questions, or greet us on [Gitter] + +[book]: https://pest-parser.github.io/book +[docs.rs]: https://docs.rs/pest +[fiddle]: https://pest-parser.github.io/#editor +[Gitter]: https://gitter.im/dragostis/pest + +## Example + +The following is an example of a grammar for a list of alpha-numeric identifiers +where the first identifier does not start with a digit: + +```rust +alpha = { 'a'..'z' | 'A'..'Z' } +digit = { '0'..'9' } + +ident = { (alpha | digit)+ } + +ident_list = _{ !digit ~ ident ~ (" " ~ ident)+ } + // ^ + // ident_list rule is silent which means it produces no tokens +``` + +Grammars are saved in separate .pest files which are never mixed with procedural +code. This results in an always up-to-date formalization of a language that is +easy to read and maintain. + +## Meaningful error reporting + +Based on the grammar definition, the parser also includes automatic error +reporting. For the example above, the input `"123"` will result in: + +``` +thread 'main' panicked at ' --> 1:1 + | +1 | 123 + | ^--- + | + = unexpected digit', src/main.rs:12 +``` +while `"ab *"` will result in: +``` +thread 'main' panicked at ' --> 1:1 + | +1 | ab * + | ^--- + | + = expected ident', src/main.rs:12 +``` + +## Pairs API + +The grammar can be used to derive a `Parser` implementation automatically. +Parsing returns an iterator of nested token pairs: + +```rust +extern crate pest; +#[macro_use] +extern crate pest_derive; + +use pest::Parser; + +#[derive(Parser)] +#[grammar = "ident.pest"] +struct IdentParser; + +fn main() { + let pairs = IdentParser::parse(Rule::ident_list, "a1 b2").unwrap_or_else(|e| panic!("{}", e)); + + // Because ident_list is silent, the iterator will contain idents + for pair in pairs { + // A pair is a combination of the rule which matched and a span of input + println!("Rule: {:?}", pair.as_rule()); + println!("Span: {:?}", pair.as_span()); + println!("Text: {}", pair.as_str()); + + // A pair can be converted to an iterator of the tokens which make it up: + for inner_pair in pair.into_inner() { + match inner_pair.as_rule() { + Rule::alpha => println!("Letter: {}", inner_pair.as_str()), + Rule::digit => println!("Digit: {}", inner_pair.as_str()), + _ => unreachable!() + }; + } + } +} +``` + +This produces the following output: +``` +Rule: ident +Span: Span { start: 0, end: 2 } +Text: a1 +Letter: a +Digit: 1 +Rule: ident +Span: Span { start: 3, end: 5 } +Text: b2 +Letter: b +Digit: 2 +``` + +## Other features + +* Precedence climbing +* Input handling +* Custom errors +* Runs on stable Rust + +## Projects using pest + +* [pest_meta](https://github.com/pest-parser/pest/blob/master/meta/src/grammar.pest) (bootstrapped) +* [AshPaper](https://github.com/shnewto/ashpaper) +* [brain](https://github.com/brain-lang/brain) +* [Chelone](https://github.com/Aaronepower/chelone) +* [comrak](https://github.com/kivikakk/comrak) +* [elastic-rs](https://github.com/cch123/elastic-rs) +* [graphql-parser](https://github.com/Keats/graphql-parser) +* [handlebars-rust](https://github.com/sunng87/handlebars-rust) +* [hexdino](https://github.com/Luz/hexdino) +* [Huia](https://gitlab.com/jimsy/huia/) +* [jql](https://github.com/yamafaktory/jql) +* [json5-rs](https://github.com/callum-oakley/json5-rs) +* [mt940](https://github.com/svenstaro/mt940-rs) +* [py_literal](https://github.com/jturner314/py_literal) +* [rouler](https://github.com/jarcane/rouler) +* [RuSh](https://github.com/lwandrebeck/RuSh) +* [rs_pbrt](https://github.com/wahn/rs_pbrt) +* [stache](https://github.com/dgraham/stache) +* [tera](https://github.com/Keats/tera) +* [ui_gen](https://github.com/emoon/ui_gen) +* [ukhasnet-parser](https://github.com/adamgreig/ukhasnet-parser) +* [ZoKrates](https://github.com/ZoKrates/ZoKrates) + +## Special thanks + +A special round of applause goes to prof. Marius Minea for his guidance and all +pest contributors, some of which being none other than my friends. diff --git a/vendor/pest/examples/parens.rs b/vendor/pest/examples/parens.rs new file mode 100644 index 000000000..2720f6346 --- /dev/null +++ b/vendor/pest/examples/parens.rs @@ -0,0 +1,75 @@ +extern crate pest; + +use std::io::{self, Write}; + +use pest::error::Error; +use pest::iterators::Pairs; +use pest::{state, ParseResult, Parser, ParserState}; + +#[allow(dead_code, non_camel_case_types)] +#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +enum Rule { + expr, + paren, + paren_end, +} + +struct ParenParser; + +impl Parser<Rule> for ParenParser { + fn parse(rule: Rule, input: &str) -> Result<Pairs<Rule>, Error<Rule>> { + fn expr(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.sequence(|s| s.repeat(|s| paren(s)).and_then(|s| s.end_of_input())) + } + + fn paren(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::paren, |s| { + s.sequence(|s| { + s.match_string("(") + .and_then(|s| { + s.optional(|s| { + s.sequence(|s| { + s.lookahead(true, |s| s.match_string("(")) + .and_then(|s| s.repeat(|s| paren(s))) + }) + }) + }) + .and_then(|s| s.rule(Rule::paren_end, |s| s.match_string(")"))) + }) + }) + } + + state(input, |state| match rule { + Rule::expr => expr(state), + Rule::paren => paren(state), + _ => unreachable!(), + }) + } +} + +#[derive(Debug)] +struct Paren(Vec<Paren>); + +fn expr(pairs: Pairs<Rule>) -> Vec<Paren> { + pairs + .filter(|p| p.as_rule() == Rule::paren) + .map(|p| Paren(expr(p.into_inner()))) + .collect() +} + +fn main() { + loop { + let mut line = String::new(); + + print!("> "); + io::stdout().flush().unwrap(); + + io::stdin().read_line(&mut line).unwrap(); + line.pop(); + + match ParenParser::parse(Rule::expr, &line) { + Ok(pairs) => println!("{:?}", expr(pairs)), + Err(e) => println!("\n{}", e), + }; + } +} diff --git a/vendor/pest/src/error.rs b/vendor/pest/src/error.rs new file mode 100644 index 000000000..d6b76a82a --- /dev/null +++ b/vendor/pest/src/error.rs @@ -0,0 +1,807 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +//! Types for different kinds of parsing failures. + +use std::cmp; +use std::error; +use std::fmt; +use std::mem; + +use position::Position; +use span::Span; +use RuleType; + +/// Parse-related error type. +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub struct Error<R> { + /// Variant of the error + pub variant: ErrorVariant<R>, + /// Location within the input string + pub location: InputLocation, + /// Line/column within the input string + pub line_col: LineColLocation, + path: Option<String>, + line: String, + continued_line: Option<String>, +} + +/// Different kinds of parsing errors. +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub enum ErrorVariant<R> { + /// Generated parsing error with expected and unexpected `Rule`s + ParsingError { + /// Positive attempts + positives: Vec<R>, + /// Negative attempts + negatives: Vec<R>, + }, + /// Custom error with a message + CustomError { + /// Short explanation + message: String, + }, +} + +/// Where an `Error` has occurred. +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub enum InputLocation { + /// `Error` was created by `Error::new_from_pos` + Pos(usize), + /// `Error` was created by `Error::new_from_span` + Span((usize, usize)), +} + +/// Line/column where an `Error` has occurred. +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub enum LineColLocation { + /// Line/column pair if `Error` was created by `Error::new_from_pos` + Pos((usize, usize)), + /// Line/column pairs if `Error` was created by `Error::new_from_span` + Span((usize, usize), (usize, usize)), +} + +impl<R: RuleType> Error<R> { + /// Creates `Error` from `ErrorVariant` and `Position`. + /// + /// # Examples + /// + /// ``` + /// # use pest::error::{Error, ErrorVariant}; + /// # use pest::Position; + /// # #[allow(non_camel_case_types)] + /// # #[allow(dead_code)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// # enum Rule { + /// # open_paren, + /// # closed_paren + /// # } + /// # let input = ""; + /// # let pos = Position::from_start(input); + /// let error = Error::new_from_pos( + /// ErrorVariant::ParsingError { + /// positives: vec![Rule::open_paren], + /// negatives: vec![Rule::closed_paren] + /// }, + /// pos + /// ); + /// + /// println!("{}", error); + /// ``` + #[allow(clippy::needless_pass_by_value)] + pub fn new_from_pos(variant: ErrorVariant<R>, pos: Position) -> Error<R> { + Error { + variant, + location: InputLocation::Pos(pos.pos()), + path: None, + line: visualize_whitespace(pos.line_of()), + continued_line: None, + line_col: LineColLocation::Pos(pos.line_col()), + } + } + + /// Creates `Error` from `ErrorVariant` and `Span`. + /// + /// # Examples + /// + /// ``` + /// # use pest::error::{Error, ErrorVariant}; + /// # use pest::{Position, Span}; + /// # #[allow(non_camel_case_types)] + /// # #[allow(dead_code)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// # enum Rule { + /// # open_paren, + /// # closed_paren + /// # } + /// # let input = ""; + /// # let start = Position::from_start(input); + /// # let end = start.clone(); + /// # let span = start.span(&end); + /// let error = Error::new_from_span( + /// ErrorVariant::ParsingError { + /// positives: vec![Rule::open_paren], + /// negatives: vec![Rule::closed_paren] + /// }, + /// span + /// ); + /// + /// println!("{}", error); + /// ``` + #[allow(clippy::needless_pass_by_value)] + pub fn new_from_span(variant: ErrorVariant<R>, span: Span) -> Error<R> { + let end = span.end_pos(); + + let mut end_line_col = end.line_col(); + // end position is after a \n, so we want to point to the visual lf symbol + if end_line_col.1 == 1 { + let mut visual_end = end.clone(); + visual_end.skip_back(1); + let lc = visual_end.line_col(); + end_line_col = (lc.0, lc.1 + 1); + }; + + let mut line_iter = span.lines(); + let start_line = visualize_whitespace(line_iter.next().unwrap_or("")); + let continued_line = line_iter.last().map(visualize_whitespace); + + Error { + variant, + location: InputLocation::Span((span.start(), end.pos())), + path: None, + line: start_line, + continued_line, + line_col: LineColLocation::Span(span.start_pos().line_col(), end_line_col), + } + } + + /// Returns `Error` variant with `path` which is shown when formatted with `Display`. + /// + /// # Examples + /// + /// ``` + /// # use pest::error::{Error, ErrorVariant}; + /// # use pest::Position; + /// # #[allow(non_camel_case_types)] + /// # #[allow(dead_code)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// # enum Rule { + /// # open_paren, + /// # closed_paren + /// # } + /// # let input = ""; + /// # let pos = Position::from_start(input); + /// Error::new_from_pos( + /// ErrorVariant::ParsingError { + /// positives: vec![Rule::open_paren], + /// negatives: vec![Rule::closed_paren] + /// }, + /// pos + /// ).with_path("file.rs"); + /// ``` + pub fn with_path(mut self, path: &str) -> Error<R> { + self.path = Some(path.to_owned()); + + self + } + + /// Renames all `Rule`s if this is a [`ParsingError`]. It does nothing when called on a + /// [`CustomError`]. + /// + /// Useful in order to rename verbose rules or have detailed per-`Rule` formatting. + /// + /// [`ParsingError`]: enum.ErrorVariant.html#variant.ParsingError + /// [`CustomError`]: enum.ErrorVariant.html#variant.CustomError + /// + /// # Examples + /// + /// ``` + /// # use pest::error::{Error, ErrorVariant}; + /// # use pest::Position; + /// # #[allow(non_camel_case_types)] + /// # #[allow(dead_code)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// # enum Rule { + /// # open_paren, + /// # closed_paren + /// # } + /// # let input = ""; + /// # let pos = Position::from_start(input); + /// Error::new_from_pos( + /// ErrorVariant::ParsingError { + /// positives: vec![Rule::open_paren], + /// negatives: vec![Rule::closed_paren] + /// }, + /// pos + /// ).renamed_rules(|rule| { + /// match *rule { + /// Rule::open_paren => "(".to_owned(), + /// Rule::closed_paren => "closed paren".to_owned() + /// } + /// }); + /// ``` + pub fn renamed_rules<F>(mut self, f: F) -> Error<R> + where + F: FnMut(&R) -> String, + { + let variant = match self.variant { + ErrorVariant::ParsingError { + positives, + negatives, + } => { + let message = Error::parsing_error_message(&positives, &negatives, f); + ErrorVariant::CustomError { message } + } + variant => variant, + }; + + self.variant = variant; + + self + } + + fn start(&self) -> (usize, usize) { + match self.line_col { + LineColLocation::Pos(line_col) => line_col, + LineColLocation::Span(start_line_col, _) => start_line_col, + } + } + + fn spacing(&self) -> String { + let line = match self.line_col { + LineColLocation::Pos((line, _)) => line, + LineColLocation::Span((start_line, _), (end_line, _)) => cmp::max(start_line, end_line), + }; + + let line_str_len = format!("{}", line).len(); + + let mut spacing = String::new(); + for _ in 0..line_str_len { + spacing.push(' '); + } + + spacing + } + + fn underline(&self) -> String { + let mut underline = String::new(); + + let mut start = self.start().1; + let end = match self.line_col { + LineColLocation::Span(_, (_, mut end)) => { + let inverted_cols = start > end; + if inverted_cols { + mem::swap(&mut start, &mut end); + start -= 1; + end += 1; + } + + Some(end) + } + _ => None, + }; + let offset = start - 1; + let line_chars = self.line.chars(); + + for c in line_chars.take(offset) { + match c { + '\t' => underline.push('\t'), + _ => underline.push(' '), + } + } + + if let Some(end) = end { + if end - start > 1 { + underline.push('^'); + for _ in 2..(end - start) { + underline.push('-'); + } + underline.push('^'); + } else { + underline.push('^'); + } + } else { + underline.push_str("^---") + } + + underline + } + + fn message(&self) -> String { + match self.variant { + ErrorVariant::ParsingError { + ref positives, + ref negatives, + } => Error::parsing_error_message(positives, negatives, |r| format!("{:?}", r)), + ErrorVariant::CustomError { ref message } => message.clone(), + } + } + + fn parsing_error_message<F>(positives: &[R], negatives: &[R], mut f: F) -> String + where + F: FnMut(&R) -> String, + { + match (negatives.is_empty(), positives.is_empty()) { + (false, false) => format!( + "unexpected {}; expected {}", + Error::enumerate(negatives, &mut f), + Error::enumerate(positives, &mut f) + ), + (false, true) => format!("unexpected {}", Error::enumerate(negatives, &mut f)), + (true, false) => format!("expected {}", Error::enumerate(positives, &mut f)), + (true, true) => "unknown parsing error".to_owned(), + } + } + + fn enumerate<F>(rules: &[R], f: &mut F) -> String + where + F: FnMut(&R) -> String, + { + match rules.len() { + 1 => f(&rules[0]), + 2 => format!("{} or {}", f(&rules[0]), f(&rules[1])), + l => { + let separated = rules + .iter() + .take(l - 1) + .map(|r| f(r)) + .collect::<Vec<_>>() + .join(", "); + format!("{}, or {}", separated, f(&rules[l - 1])) + } + } + } + + pub(crate) fn format(&self) -> String { + let spacing = self.spacing(); + let path = self + .path + .as_ref() + .map(|path| format!("{}:", path)) + .unwrap_or_default(); + + let pair = (self.line_col.clone(), &self.continued_line); + if let (LineColLocation::Span(_, end), &Some(ref continued_line)) = pair { + let has_line_gap = end.0 - self.start().0 > 1; + if has_line_gap { + format!( + "{s }--> {p}{ls}:{c}\n\ + {s } |\n\ + {ls:w$} | {line}\n\ + {s } | ...\n\ + {le:w$} | {continued_line}\n\ + {s } | {underline}\n\ + {s } |\n\ + {s } = {message}", + s = spacing, + w = spacing.len(), + p = path, + ls = self.start().0, + le = end.0, + c = self.start().1, + line = self.line, + continued_line = continued_line, + underline = self.underline(), + message = self.message() + ) + } else { + format!( + "{s }--> {p}{ls}:{c}\n\ + {s } |\n\ + {ls:w$} | {line}\n\ + {le:w$} | {continued_line}\n\ + {s } | {underline}\n\ + {s } |\n\ + {s } = {message}", + s = spacing, + w = spacing.len(), + p = path, + ls = self.start().0, + le = end.0, + c = self.start().1, + line = self.line, + continued_line = continued_line, + underline = self.underline(), + message = self.message() + ) + } + } else { + format!( + "{s}--> {p}{l}:{c}\n\ + {s} |\n\ + {l} | {line}\n\ + {s} | {underline}\n\ + {s} |\n\ + {s} = {message}", + s = spacing, + p = path, + l = self.start().0, + c = self.start().1, + line = self.line, + underline = self.underline(), + message = self.message() + ) + } + } +} + +impl<R: RuleType> fmt::Display for Error<R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.format()) + } +} + +impl<'i, R: RuleType> error::Error for Error<R> { + fn description(&self) -> &str { + match self.variant { + ErrorVariant::ParsingError { .. } => "parsing error", + ErrorVariant::CustomError { ref message } => message, + } + } +} + +fn visualize_whitespace(input: &str) -> String { + input.to_owned().replace('\r', "␍").replace('\n', "␊") +} + +#[cfg(test)] +mod tests { + use super::super::position; + use super::*; + + #[test] + fn display_parsing_error_mixed() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![1, 2, 3], + negatives: vec![4, 5, 6], + }, + pos, + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = unexpected 4, 5, or 6; expected 1, 2, or 3", + ] + .join("\n") + ); + } + + #[test] + fn display_parsing_error_positives() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![1, 2], + negatives: vec![], + }, + pos, + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = expected 1 or 2", + ] + .join("\n") + ); + } + + #[test] + fn display_parsing_error_negatives() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![], + negatives: vec![4, 5, 6], + }, + pos, + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = unexpected 4, 5, or 6", + ] + .join("\n") + ); + } + + #[test] + fn display_parsing_error_unknown() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![], + negatives: vec![], + }, + pos, + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = unknown parsing error", + ] + .join("\n") + ); + } + + #[test] + fn display_custom_pos() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::CustomError { + message: "error: big one".to_owned(), + }, + pos, + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = error: big one", + ] + .join("\n") + ); + } + + #[test] + fn display_custom_span_two_lines() { + let input = "ab\ncd\nefgh"; + let start = position::Position::new(input, 4).unwrap(); + let end = position::Position::new(input, 9).unwrap(); + let error: Error<u32> = Error::new_from_span( + ErrorVariant::CustomError { + message: "error: big one".to_owned(), + }, + start.span(&end), + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + "3 | efgh", + " | ^^", + " |", + " = error: big one", + ] + .join("\n") + ); + } + + #[test] + fn display_custom_span_three_lines() { + let input = "ab\ncd\nefgh"; + let start = position::Position::new(input, 1).unwrap(); + let end = position::Position::new(input, 9).unwrap(); + let error: Error<u32> = Error::new_from_span( + ErrorVariant::CustomError { + message: "error: big one".to_owned(), + }, + start.span(&end), + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 1:2", + " |", + "1 | ab␊", + " | ...", + "3 | efgh", + " | ^^", + " |", + " = error: big one", + ] + .join("\n") + ); + } + + #[test] + fn display_custom_span_two_lines_inverted_cols() { + let input = "abcdef\ngh"; + let start = position::Position::new(input, 5).unwrap(); + let end = position::Position::new(input, 8).unwrap(); + let error: Error<u32> = Error::new_from_span( + ErrorVariant::CustomError { + message: "error: big one".to_owned(), + }, + start.span(&end), + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 1:6", + " |", + "1 | abcdef␊", + "2 | gh", + " | ^----^", + " |", + " = error: big one", + ] + .join("\n") + ); + } + + #[test] + fn display_custom_span_end_after_newline() { + let input = "abcdef\n"; + let start = position::Position::new(input, 0).unwrap(); + let end = position::Position::new(input, 7).unwrap(); + assert!(start.at_start()); + assert!(end.at_end()); + + let error: Error<u32> = Error::new_from_span( + ErrorVariant::CustomError { + message: "error: big one".to_owned(), + }, + start.span(&end), + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 1:1", + " |", + "1 | abcdef␊", + " | ^-----^", + " |", + " = error: big one", + ] + .join("\n") + ); + } + + #[test] + fn display_custom_span_empty() { + let input = ""; + let start = position::Position::new(input, 0).unwrap(); + let end = position::Position::new(input, 0).unwrap(); + assert!(start.at_start()); + assert!(end.at_end()); + + let error: Error<u32> = Error::new_from_span( + ErrorVariant::CustomError { + message: "error: empty".to_owned(), + }, + start.span(&end), + ); + + assert_eq!( + format!("{}", error), + vec![ + " --> 1:1", + " |", + "1 | ", + " | ^", + " |", + " = error: empty", + ] + .join("\n") + ); + } + + #[test] + fn mapped_parsing_error() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![1, 2, 3], + negatives: vec![4, 5, 6], + }, + pos, + ) + .renamed_rules(|n| format!("{}", n + 1)); + + assert_eq!( + format!("{}", error), + vec![ + " --> 2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = unexpected 5, 6, or 7; expected 2, 3, or 4", + ] + .join("\n") + ); + } + + #[test] + fn error_with_path() { + let input = "ab\ncd\nef"; + let pos = position::Position::new(input, 4).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![1, 2, 3], + negatives: vec![4, 5, 6], + }, + pos, + ) + .with_path("file.rs"); + + assert_eq!( + format!("{}", error), + vec![ + " --> file.rs:2:2", + " |", + "2 | cd␊", + " | ^---", + " |", + " = unexpected 4, 5, or 6; expected 1, 2, or 3", + ] + .join("\n") + ); + } + + #[test] + fn underline_with_tabs() { + let input = "a\txbc"; + let pos = position::Position::new(input, 2).unwrap(); + let error: Error<u32> = Error::new_from_pos( + ErrorVariant::ParsingError { + positives: vec![1, 2, 3], + negatives: vec![4, 5, 6], + }, + pos, + ) + .with_path("file.rs"); + + assert_eq!( + format!("{}", error), + vec![ + " --> file.rs:1:3", + " |", + "1 | a xbc", + " | ^---", + " |", + " = unexpected 4, 5, or 6; expected 1, 2, or 3", + ] + .join("\n") + ); + } +} diff --git a/vendor/pest/src/iterators/flat_pairs.rs b/vendor/pest/src/iterators/flat_pairs.rs new file mode 100644 index 000000000..bb5bbb185 --- /dev/null +++ b/vendor/pest/src/iterators/flat_pairs.rs @@ -0,0 +1,177 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::fmt; +use std::rc::Rc; + +use super::pair::{self, Pair}; +use super::queueable_token::QueueableToken; +use super::tokens::{self, Tokens}; +use RuleType; + +/// An iterator over [`Pair`]s. It is created by [`Pairs::flatten`]. +/// +/// [`Pair`]: struct.Pair.html +/// [`Pairs::flatten`]: struct.Pairs.html#method.flatten +pub struct FlatPairs<'i, R> { + /// # Safety + /// + /// All `QueueableToken`s' `input_pos` must be valid character boundary indices into `input`. + queue: Rc<Vec<QueueableToken<R>>>, + input: &'i str, + start: usize, + end: usize, +} + +/// # Safety +/// +/// All `QueueableToken`s' `input_pos` must be valid character boundary indices into `input`. +pub unsafe fn new<R: RuleType>( + queue: Rc<Vec<QueueableToken<R>>>, + input: &str, + start: usize, + end: usize, +) -> FlatPairs<R> { + FlatPairs { + queue, + input, + start, + end, + } +} + +impl<'i, R: RuleType> FlatPairs<'i, R> { + /// Returns the `Tokens` for these pairs. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = ""; + /// let pairs = pest::state(input, |state| { + /// // generating Token pair with Rule::a ... + /// # state.rule(Rule::a, |s| Ok(s)) + /// }).unwrap(); + /// let tokens: Vec<_> = pairs.flatten().tokens().collect(); + /// + /// assert_eq!(tokens.len(), 2); + /// ``` + #[inline] + pub fn tokens(self) -> Tokens<'i, R> { + tokens::new(self.queue, self.input, self.start, self.end) + } + + fn next_start(&mut self) { + self.start += 1; + + while self.start < self.end && !self.is_start(self.start) { + self.start += 1; + } + } + + fn next_start_from_end(&mut self) { + self.end -= 1; + + while self.end >= self.start && !self.is_start(self.end) { + self.end -= 1; + } + } + + fn is_start(&self, index: usize) -> bool { + match self.queue[index] { + QueueableToken::Start { .. } => true, + QueueableToken::End { .. } => false, + } + } +} + +impl<'i, R: RuleType> Iterator for FlatPairs<'i, R> { + type Item = Pair<'i, R>; + + fn next(&mut self) -> Option<Self::Item> { + if self.start >= self.end { + return None; + } + + let pair = unsafe { pair::new(Rc::clone(&self.queue), self.input, self.start) }; + + self.next_start(); + + Some(pair) + } +} + +impl<'i, R: RuleType> DoubleEndedIterator for FlatPairs<'i, R> { + fn next_back(&mut self) -> Option<Self::Item> { + if self.end <= self.start { + return None; + } + + self.next_start_from_end(); + + let pair = unsafe { pair::new(Rc::clone(&self.queue), self.input, self.end) }; + + Some(pair) + } +} + +impl<'i, R: RuleType> fmt::Debug for FlatPairs<'i, R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("FlatPairs") + .field("pairs", &self.clone().collect::<Vec<_>>()) + .finish() + } +} + +impl<'i, R: Clone> Clone for FlatPairs<'i, R> { + fn clone(&self) -> FlatPairs<'i, R> { + FlatPairs { + queue: Rc::clone(&self.queue), + input: self.input, + start: self.start, + end: self.end, + } + } +} + +#[cfg(test)] +mod tests { + use super::super::super::macros::tests::*; + use super::super::super::Parser; + + #[test] + fn iter_for_flat_pairs() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + assert_eq!( + pairs.flatten().map(|p| p.as_rule()).collect::<Vec<Rule>>(), + vec![Rule::a, Rule::b, Rule::c] + ); + } + + #[test] + fn double_ended_iter_for_flat_pairs() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + assert_eq!( + pairs + .flatten() + .rev() + .map(|p| p.as_rule()) + .collect::<Vec<Rule>>(), + vec![Rule::c, Rule::b, Rule::a] + ); + } +} diff --git a/vendor/pest/src/iterators/mod.rs b/vendor/pest/src/iterators/mod.rs new file mode 100644 index 000000000..1a7896371 --- /dev/null +++ b/vendor/pest/src/iterators/mod.rs @@ -0,0 +1,22 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +//! Types and iterators for parser output. + +mod flat_pairs; +mod pair; +pub(crate) mod pairs; +mod queueable_token; +mod tokens; + +pub use self::flat_pairs::FlatPairs; +pub use self::pair::Pair; +pub use self::pairs::Pairs; +pub(crate) use self::queueable_token::QueueableToken; +pub use self::tokens::Tokens; diff --git a/vendor/pest/src/iterators/pair.rs b/vendor/pest/src/iterators/pair.rs new file mode 100644 index 000000000..88844a353 --- /dev/null +++ b/vendor/pest/src/iterators/pair.rs @@ -0,0 +1,389 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::fmt; +use std::hash::{Hash, Hasher}; +use std::ptr; +use std::rc::Rc; +use std::str; + +#[cfg(feature = "pretty-print")] +use serde::ser::SerializeStruct; + +use super::pairs::{self, Pairs}; +use super::queueable_token::QueueableToken; +use super::tokens::{self, Tokens}; +use span::{self, Span}; +use RuleType; + +/// A matching pair of [`Token`]s and everything between them. +/// +/// A matching `Token` pair is formed by a `Token::Start` and a subsequent `Token::End` with the +/// same `Rule`, with the condition that all `Token`s between them can form such pairs as well. +/// This is similar to the [brace matching problem](https://en.wikipedia.org/wiki/Brace_matching) in +/// editors. +/// +/// [`Token`]: ../enum.Token.html +#[derive(Clone)] +pub struct Pair<'i, R> { + /// # Safety + /// + /// All `QueueableToken`s' `input_pos` must be valid character boundary indices into `input`. + queue: Rc<Vec<QueueableToken<R>>>, + input: &'i str, + /// Token index into `queue`. + start: usize, +} + +/// # Safety +/// +/// All `QueueableToken`s' `input_pos` must be valid character boundary indices into `input`. +pub unsafe fn new<R: RuleType>( + queue: Rc<Vec<QueueableToken<R>>>, + input: &str, + start: usize, +) -> Pair<R> { + Pair { + queue, + input, + start, + } +} + +impl<'i, R: RuleType> Pair<'i, R> { + /// Returns the `Rule` of the `Pair`. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = ""; + /// let pair = pest::state(input, |state| { + /// // generating Token pair with Rule::a ... + /// # state.rule(Rule::a, |s| Ok(s)) + /// }).unwrap().next().unwrap(); + /// + /// assert_eq!(pair.as_rule(), Rule::a); + /// ``` + #[inline] + pub fn as_rule(&self) -> R { + match self.queue[self.pair()] { + QueueableToken::End { rule, .. } => rule, + _ => unreachable!(), + } + } + + /// Captures a slice from the `&str` defined by the token `Pair`. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "ab"; + /// let pair = pest::state(input, |state| { + /// // generating Token pair with Rule::ab ... + /// # state.rule(Rule::ab, |s| s.match_string("ab")) + /// }).unwrap().next().unwrap(); + /// + /// assert_eq!(pair.as_str(), "ab"); + /// ``` + #[inline] + pub fn as_str(&self) -> &'i str { + let start = self.pos(self.start); + let end = self.pos(self.pair()); + + // Generated positions always come from Positions and are UTF-8 borders. + &self.input[start..end] + } + + /// Returns the `Span` defined by the `Pair`, consuming it. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "ab"; + /// let pair = pest::state(input, |state| { + /// // generating Token pair with Rule::ab ... + /// # state.rule(Rule::ab, |s| s.match_string("ab")) + /// }).unwrap().next().unwrap(); + /// + /// assert_eq!(pair.into_span().as_str(), "ab"); + /// ``` + #[inline] + #[deprecated(since = "2.0.0", note = "Please use `as_span` instead")] + pub fn into_span(self) -> Span<'i> { + self.as_span() + } + + /// Returns the `Span` defined by the `Pair`, **without** consuming it. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "ab"; + /// let pair = pest::state(input, |state| { + /// // generating Token pair with Rule::ab ... + /// # state.rule(Rule::ab, |s| s.match_string("ab")) + /// }).unwrap().next().unwrap(); + /// + /// assert_eq!(pair.as_span().as_str(), "ab"); + /// ``` + #[inline] + pub fn as_span(&self) -> Span<'i> { + let start = self.pos(self.start); + let end = self.pos(self.pair()); + + // Generated positions always come from Positions and are UTF-8 borders. + unsafe { span::Span::new_unchecked(self.input, start, end) } + } + + /// Returns the inner `Pairs` between the `Pair`, consuming it. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = ""; + /// let pair = pest::state(input, |state| { + /// // generating Token pair with Rule::a ... + /// # state.rule(Rule::a, |s| Ok(s)) + /// }).unwrap().next().unwrap(); + /// + /// assert!(pair.into_inner().next().is_none()); + /// ``` + #[inline] + pub fn into_inner(self) -> Pairs<'i, R> { + let pair = self.pair(); + + pairs::new(self.queue, self.input, self.start + 1, pair) + } + + /// Returns the `Tokens` for the `Pair`. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = ""; + /// let pair = pest::state(input, |state| { + /// // generating Token pair with Rule::a ... + /// # state.rule(Rule::a, |s| Ok(s)) + /// }).unwrap().next().unwrap(); + /// let tokens: Vec<_> = pair.tokens().collect(); + /// + /// assert_eq!(tokens.len(), 2); + /// ``` + #[inline] + pub fn tokens(self) -> Tokens<'i, R> { + let end = self.pair(); + + tokens::new(self.queue, self.input, self.start, end + 1) + } + + /// Generates a string that stores the lexical information of `self` in + /// a pretty-printed JSON format. + #[cfg(feature = "pretty-print")] + pub fn to_json(&self) -> String { + ::serde_json::to_string_pretty(self).expect("Failed to pretty-print Pair to json.") + } + + fn pair(&self) -> usize { + match self.queue[self.start] { + QueueableToken::Start { + end_token_index, .. + } => end_token_index, + _ => unreachable!(), + } + } + + fn pos(&self, index: usize) -> usize { + match self.queue[index] { + QueueableToken::Start { input_pos, .. } | QueueableToken::End { input_pos, .. } => { + input_pos + } + } + } +} + +impl<'i, R: RuleType> Pairs<'i, R> { + /// Create a new `Pairs` iterator containing just the single `Pair`. + pub fn single(pair: Pair<'i, R>) -> Self { + let end = pair.pair(); + pairs::new(pair.queue, pair.input, pair.start, end) + } +} + +impl<'i, R: RuleType> fmt::Debug for Pair<'i, R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Pair") + .field("rule", &self.as_rule()) + .field("span", &self.as_span()) + .field("inner", &self.clone().into_inner().collect::<Vec<_>>()) + .finish() + } +} + +impl<'i, R: RuleType> fmt::Display for Pair<'i, R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let rule = self.as_rule(); + let start = self.pos(self.start); + let end = self.pos(self.pair()); + let mut pairs = self.clone().into_inner().peekable(); + + if pairs.peek().is_none() { + write!(f, "{:?}({}, {})", rule, start, end) + } else { + write!( + f, + "{:?}({}, {}, [{}])", + rule, + start, + end, + pairs + .map(|pair| format!("{}", pair)) + .collect::<Vec<_>>() + .join(", ") + ) + } + } +} + +impl<'i, R: PartialEq> PartialEq for Pair<'i, R> { + fn eq(&self, other: &Pair<'i, R>) -> bool { + Rc::ptr_eq(&self.queue, &other.queue) + && ptr::eq(self.input, other.input) + && self.start == other.start + } +} + +impl<'i, R: Eq> Eq for Pair<'i, R> {} + +impl<'i, R: Hash> Hash for Pair<'i, R> { + fn hash<H: Hasher>(&self, state: &mut H) { + (&*self.queue as *const Vec<QueueableToken<R>>).hash(state); + (self.input as *const str).hash(state); + self.start.hash(state); + } +} + +#[cfg(feature = "pretty-print")] +impl<'i, R: RuleType> ::serde::Serialize for Pair<'i, R> { + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: ::serde::Serializer, + { + let start = self.pos(self.start); + let end = self.pos(self.pair()); + let rule = format!("{:?}", self.as_rule()); + let inner = self.clone().into_inner(); + + let mut ser = serializer.serialize_struct("Pairs", 3)?; + ser.serialize_field("pos", &(start, end))?; + ser.serialize_field("rule", &rule)?; + + if inner.peek().is_none() { + ser.serialize_field("inner", &self.as_str())?; + } else { + ser.serialize_field("inner", &inner)?; + } + + ser.end() + } +} + +#[cfg(test)] +mod tests { + use macros::tests::*; + use parser::Parser; + + #[test] + #[cfg(feature = "pretty-print")] + fn test_pretty_print() { + let pair = AbcParser::parse(Rule::a, "abcde").unwrap().next().unwrap(); + + let expected = r#"{ + "pos": [ + 0, + 3 + ], + "rule": "a", + "inner": { + "pos": [ + 1, + 2 + ], + "pairs": [ + { + "pos": [ + 1, + 2 + ], + "rule": "b", + "inner": "b" + } + ] + } +}"#; + + assert_eq!(expected, pair.to_json()); + } + + #[test] + fn pair_into_inner() { + let pair = AbcParser::parse(Rule::a, "abcde").unwrap().next().unwrap(); // the tokens a(b()) + + let pairs = pair.into_inner(); // the tokens b() + + assert_eq!(2, pairs.tokens().count()); + } +} diff --git a/vendor/pest/src/iterators/pairs.rs b/vendor/pest/src/iterators/pairs.rs new file mode 100644 index 000000000..abae123e1 --- /dev/null +++ b/vendor/pest/src/iterators/pairs.rs @@ -0,0 +1,419 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::fmt; +use std::hash::{Hash, Hasher}; +use std::ptr; +use std::rc::Rc; +use std::str; + +#[cfg(feature = "pretty-print")] +use serde::ser::SerializeStruct; + +use super::flat_pairs::{self, FlatPairs}; +use super::pair::{self, Pair}; +use super::queueable_token::QueueableToken; +use super::tokens::{self, Tokens}; +use RuleType; + +/// An iterator over [`Pair`]s. It is created by [`pest::state`] and [`Pair::into_inner`]. +/// +/// [`Pair`]: struct.Pair.html +/// [`pest::state`]: ../fn.state.html +/// [`Pair::into_inner`]: struct.Pair.html#method.into_inner +#[derive(Clone)] +pub struct Pairs<'i, R> { + queue: Rc<Vec<QueueableToken<R>>>, + input: &'i str, + start: usize, + end: usize, +} + +pub fn new<R: RuleType>( + queue: Rc<Vec<QueueableToken<R>>>, + input: &str, + start: usize, + end: usize, +) -> Pairs<R> { + Pairs { + queue, + input, + start, + end, + } +} + +impl<'i, R: RuleType> Pairs<'i, R> { + /// Captures a slice from the `&str` defined by the starting position of the first token `Pair` + /// and the ending position of the last token `Pair` of the `Pairs`. This also captures + /// the input between those two token `Pair`s. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a, + /// b + /// } + /// + /// let input = "a b"; + /// let pairs = pest::state(input, |state| { + /// // generating Token pairs with Rule::a and Rule::b ... + /// # state.rule(Rule::a, |s| s.match_string("a")).and_then(|s| s.skip(1)) + /// # .and_then(|s| s.rule(Rule::b, |s| s.match_string("b"))) + /// }).unwrap(); + /// + /// assert_eq!(pairs.as_str(), "a b"); + /// ``` + #[inline] + pub fn as_str(&self) -> &'i str { + if self.start < self.end { + let start = self.pos(self.start); + let end = self.pos(self.end - 1); + // Generated positions always come from Positions and are UTF-8 borders. + &self.input[start..end] + } else { + "" + } + } + + /// Captures inner token `Pair`s and concatenates resulting `&str`s. This does not capture + /// the input between token `Pair`s. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a, + /// b + /// } + /// + /// let input = "a b"; + /// let pairs = pest::state(input, |state| { + /// // generating Token pairs with Rule::a and Rule::b ... + /// # state.rule(Rule::a, |s| s.match_string("a")).and_then(|s| s.skip(1)) + /// # .and_then(|s| s.rule(Rule::b, |s| s.match_string("b"))) + /// }).unwrap(); + /// + /// assert_eq!(pairs.concat(), "ab"); + /// ``` + #[inline] + pub fn concat(&self) -> String { + self.clone() + .fold(String::new(), |string, pair| string + pair.as_str()) + } + + /// Flattens the `Pairs`. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a, + /// b + /// } + /// + /// let input = ""; + /// let pairs = pest::state(input, |state| { + /// // generating nested Token pair with Rule::b inside Rule::a + /// # state.rule(Rule::a, |state| { + /// # state.rule(Rule::b, |s| Ok(s)) + /// # }) + /// }).unwrap(); + /// let tokens: Vec<_> = pairs.flatten().tokens().collect(); + /// + /// assert_eq!(tokens.len(), 4); + /// ``` + #[inline] + pub fn flatten(self) -> FlatPairs<'i, R> { + unsafe { flat_pairs::new(self.queue, self.input, self.start, self.end) } + } + + /// Returns the `Tokens` for the `Pairs`. + /// + /// # Examples + /// + /// ``` + /// # use std::rc::Rc; + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = ""; + /// let pairs = pest::state(input, |state| { + /// // generating Token pair with Rule::a ... + /// # state.rule(Rule::a, |s| Ok(s)) + /// }).unwrap(); + /// let tokens: Vec<_> = pairs.tokens().collect(); + /// + /// assert_eq!(tokens.len(), 2); + /// ``` + #[inline] + pub fn tokens(self) -> Tokens<'i, R> { + tokens::new(self.queue, self.input, self.start, self.end) + } + + /// Peek at the first inner `Pair` without changing the position of this iterator. + #[inline] + pub fn peek(&self) -> Option<Pair<'i, R>> { + if self.start < self.end { + Some(unsafe { pair::new(Rc::clone(&self.queue), self.input, self.start) }) + } else { + None + } + } + + /// Generates a string that stores the lexical information of `self` in + /// a pretty-printed JSON format. + #[cfg(feature = "pretty-print")] + pub fn to_json(&self) -> String { + ::serde_json::to_string_pretty(self).expect("Failed to pretty-print Pairs to json.") + } + + fn pair(&self) -> usize { + match self.queue[self.start] { + QueueableToken::Start { + end_token_index, .. + } => end_token_index, + _ => unreachable!(), + } + } + + fn pair_from_end(&self) -> usize { + match self.queue[self.end - 1] { + QueueableToken::End { + start_token_index, .. + } => start_token_index, + _ => unreachable!(), + } + } + + fn pos(&self, index: usize) -> usize { + match self.queue[index] { + QueueableToken::Start { input_pos, .. } | QueueableToken::End { input_pos, .. } => { + input_pos + } + } + } +} + +impl<'i, R: RuleType> Iterator for Pairs<'i, R> { + type Item = Pair<'i, R>; + + fn next(&mut self) -> Option<Self::Item> { + let pair = self.peek()?; + self.start = self.pair() + 1; + Some(pair) + } +} + +impl<'i, R: RuleType> DoubleEndedIterator for Pairs<'i, R> { + fn next_back(&mut self) -> Option<Self::Item> { + if self.end <= self.start { + return None; + } + + self.end = self.pair_from_end(); + + let pair = unsafe { pair::new(Rc::clone(&self.queue), self.input, self.end) }; + + Some(pair) + } +} + +impl<'i, R: RuleType> fmt::Debug for Pairs<'i, R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +impl<'i, R: RuleType> fmt::Display for Pairs<'i, R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "[{}]", + self.clone() + .map(|pair| format!("{}", pair)) + .collect::<Vec<_>>() + .join(", ") + ) + } +} + +impl<'i, R: PartialEq> PartialEq for Pairs<'i, R> { + fn eq(&self, other: &Pairs<'i, R>) -> bool { + Rc::ptr_eq(&self.queue, &other.queue) + && ptr::eq(self.input, other.input) + && self.start == other.start + && self.end == other.end + } +} + +impl<'i, R: Eq> Eq for Pairs<'i, R> {} + +impl<'i, R: Hash> Hash for Pairs<'i, R> { + fn hash<H: Hasher>(&self, state: &mut H) { + (&*self.queue as *const Vec<QueueableToken<R>>).hash(state); + (self.input as *const str).hash(state); + self.start.hash(state); + self.end.hash(state); + } +} + +#[cfg(feature = "pretty-print")] +impl<'i, R: RuleType> ::serde::Serialize for Pairs<'i, R> { + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: ::serde::Serializer, + { + let start = self.pos(self.start); + let end = self.pos(self.end - 1); + let pairs = self.clone().collect::<Vec<_>>(); + + let mut ser = serializer.serialize_struct("Pairs", 2)?; + ser.serialize_field("pos", &(start, end))?; + ser.serialize_field("pairs", &pairs)?; + ser.end() + } +} + +#[cfg(test)] +mod tests { + use super::super::super::macros::tests::*; + use super::super::super::Parser; + + #[test] + #[cfg(feature = "pretty-print")] + fn test_pretty_print() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + let expected = r#"{ + "pos": [ + 0, + 5 + ], + "pairs": [ + { + "pos": [ + 0, + 3 + ], + "rule": "a", + "inner": { + "pos": [ + 1, + 2 + ], + "pairs": [ + { + "pos": [ + 1, + 2 + ], + "rule": "b", + "inner": "b" + } + ] + } + }, + { + "pos": [ + 4, + 5 + ], + "rule": "c", + "inner": "e" + } + ] +}"#; + + assert_eq!(expected, pairs.to_json()); + } + + #[test] + fn as_str() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + assert_eq!(pairs.as_str(), "abcde"); + } + + #[test] + fn as_str_empty() { + let mut pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + assert_eq!(pairs.nth(1).unwrap().into_inner().as_str(), ""); + } + + #[test] + fn concat() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + assert_eq!(pairs.concat(), "abce"); + } + + #[test] + fn pairs_debug() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + #[rustfmt::skip] + assert_eq!( + format!("{:?}", pairs), + "[\ + Pair { rule: a, span: Span { str: \"abc\", start: 0, end: 3 }, inner: [\ + Pair { rule: b, span: Span { str: \"b\", start: 1, end: 2 }, inner: [] }\ + ] }, \ + Pair { rule: c, span: Span { str: \"e\", start: 4, end: 5 }, inner: [] }\ + ]" + .to_owned() + ); + } + + #[test] + fn pairs_display() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + + assert_eq!( + format!("{}", pairs), + "[a(0, 3, [b(1, 2)]), c(4, 5)]".to_owned() + ); + } + + #[test] + fn iter_for_pairs() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + assert_eq!( + pairs.map(|p| p.as_rule()).collect::<Vec<Rule>>(), + vec![Rule::a, Rule::c] + ); + } + + #[test] + fn double_ended_iter_for_pairs() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + assert_eq!( + pairs.rev().map(|p| p.as_rule()).collect::<Vec<Rule>>(), + vec![Rule::c, Rule::a] + ); + } +} diff --git a/vendor/pest/src/iterators/queueable_token.rs b/vendor/pest/src/iterators/queueable_token.rs new file mode 100644 index 000000000..7d56749bb --- /dev/null +++ b/vendor/pest/src/iterators/queueable_token.rs @@ -0,0 +1,27 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +// This structure serves to improve performance over Token objects in two ways: +// +// * it is smaller than a Token, leading to both less memory use when stored in the queue but also +// increased speed when pushing to the queue +// * it finds its pair in O(1) time instead of O(N), since pair positions are known at parse time +// and can easily be stored instead of recomputed +#[derive(Debug)] +pub enum QueueableToken<R> { + Start { + end_token_index: usize, + input_pos: usize, + }, + End { + start_token_index: usize, + rule: R, + input_pos: usize, + }, +} diff --git a/vendor/pest/src/iterators/tokens.rs b/vendor/pest/src/iterators/tokens.rs new file mode 100644 index 000000000..59b75c520 --- /dev/null +++ b/vendor/pest/src/iterators/tokens.rs @@ -0,0 +1,144 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::fmt; +use std::rc::Rc; +use std::str; + +use super::queueable_token::QueueableToken; +use position; +use token::Token; +use RuleType; + +/// An iterator over [`Token`]s. It is created by [`Pair::tokens`] and [`Pairs::tokens`]. +/// +/// [`Token`]: ../enum.Token.html +/// [`Pair::tokens`]: struct.Pair.html#method.tokens +/// [`Pairs::tokens`]: struct.Pairs.html#method.tokens +#[derive(Clone)] +pub struct Tokens<'i, R> { + /// # Safety: + /// + /// All `QueueableToken`s' `input_pos` must be valid character boundary indices into `input`. + queue: Rc<Vec<QueueableToken<R>>>, + input: &'i str, + start: usize, + end: usize, +} + +// TODO(safety): QueueableTokens must be valid indices into input. +pub fn new<R: RuleType>( + queue: Rc<Vec<QueueableToken<R>>>, + input: &str, + start: usize, + end: usize, +) -> Tokens<R> { + if cfg!(debug_assertions) { + for tok in queue.iter() { + match *tok { + QueueableToken::Start { input_pos, .. } | QueueableToken::End { input_pos, .. } => { + assert!( + input.get(input_pos..).is_some(), + "💥 UNSAFE `Tokens` CREATED 💥" + ) + } + } + } + } + + Tokens { + queue, + input, + start, + end, + } +} + +impl<'i, R: RuleType> Tokens<'i, R> { + fn create_token(&self, index: usize) -> Token<'i, R> { + match self.queue[index] { + QueueableToken::Start { + end_token_index, + input_pos, + } => { + let rule = match self.queue[end_token_index] { + QueueableToken::End { rule, .. } => rule, + _ => unreachable!(), + }; + + Token::Start { + rule, + // QueueableTokens are safely created. + pos: unsafe { position::Position::new_unchecked(self.input, input_pos) }, + } + } + QueueableToken::End { + rule, input_pos, .. + } => { + Token::End { + rule, + // QueueableTokens are safely created. + pos: unsafe { position::Position::new_unchecked(self.input, input_pos) }, + } + } + } + } +} + +impl<'i, R: RuleType> Iterator for Tokens<'i, R> { + type Item = Token<'i, R>; + + fn next(&mut self) -> Option<Self::Item> { + if self.start >= self.end { + return None; + } + + let token = self.create_token(self.start); + + self.start += 1; + + Some(token) + } +} + +impl<'i, R: RuleType> DoubleEndedIterator for Tokens<'i, R> { + fn next_back(&mut self) -> Option<Self::Item> { + if self.end <= self.start { + return None; + } + + let token = self.create_token(self.end - 1); + + self.end -= 1; + + Some(token) + } +} + +impl<'i, R: RuleType> fmt::Debug for Tokens<'i, R> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +#[cfg(test)] +mod tests { + use super::super::super::macros::tests::*; + use super::super::super::Parser; + use super::Token; + + #[test] + fn double_ended_iter_for_tokens() { + let pairs = AbcParser::parse(Rule::a, "abcde").unwrap(); + let mut tokens = pairs.clone().tokens().collect::<Vec<Token<Rule>>>(); + tokens.reverse(); + let reverse_tokens = pairs.tokens().rev().collect::<Vec<Token<Rule>>>(); + assert_eq!(tokens, reverse_tokens); + } +} diff --git a/vendor/pest/src/lib.rs b/vendor/pest/src/lib.rs new file mode 100644 index 000000000..c55518c25 --- /dev/null +++ b/vendor/pest/src/lib.rs @@ -0,0 +1,103 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +//! # pest. The Elegant Parser +//! +//! pest is a general purpose parser written in Rust with a focus on accessibility, correctness, +//! and performance. It uses parsing expression grammars (or [PEG]) as input, which are similar in +//! spirit to regular expressions, but which offer the enhanced expressivity needed to parse +//! complex languages. +//! +//! [PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar +//! +//! ## Getting started +//! +//! The recommended way to start parsing with pest is to read the official [book]. +//! +//! Other helpful resources: +//! +//! * API reference on [docs.rs] +//! * play with grammars and share them on our [fiddle] +//! * leave feedback, ask questions, or greet us on [Gitter] +//! +//! [book]: https://pest-parser.github.io/book +//! [docs.rs]: https://docs.rs/pest +//! [fiddle]: https://pest-parser.github.io/#editor +//! [Gitter]: https://gitter.im/dragostis/pest +//! +//! ## Usage +//! +//! The core of pest is the trait [`Parser`], which provides an interface to the parsing +//! functionality. +//! +//! The accompanying crate `pest_derive` can automatically generate a [`Parser`] from a PEG +//! grammar. Using `pest_derive` is highly encouraged, but it is also possible to implement +//! [`Parser`] manually if required. +//! +//! ## `.pest` files +//! +//! Grammar definitions reside in custom `.pest` files located in the crate `src` directory. +//! Parsers are automatically generated from these files using `#[derive(Parser)]` and a special +//! `#[grammar = "..."]` attribute on a dummy struct. +//! +//! ```ignore +//! #[derive(Parser)] +//! #[grammar = "path/to/my_grammar.pest"] // relative to src +//! struct MyParser; +//! ``` +//! +//! The syntax of `.pest` files is documented in the [`pest_derive` crate]. +//! +//! ## Inline grammars +//! +//! Grammars can also be inlined by using the `#[grammar_inline = "..."]` attribute. +//! +//! [`Parser`]: trait.Parser.html +//! [`pest_derive` crate]: https://docs.rs/pest_derive/ + +#![doc(html_root_url = "https://docs.rs/pest")] + +extern crate ucd_trie; + +#[cfg(feature = "pretty-print")] +extern crate serde; +#[cfg(feature = "pretty-print")] +extern crate serde_json; + +pub use parser::Parser; +pub use parser_state::{state, Atomicity, Lookahead, MatchDir, ParseResult, ParserState}; +pub use position::Position; +pub use span::{Lines, Span}; +use std::fmt::Debug; +use std::hash::Hash; +pub use token::Token; + +pub mod error; +pub mod iterators; +mod macros; +mod parser; +mod parser_state; +mod position; +pub mod prec_climber; +mod span; +mod stack; +mod token; +#[doc(hidden)] +pub mod unicode; + +/// A trait which parser rules must implement. +/// +/// This trait is set up so that any struct that implements all of its required traits will +/// automatically implement this trait as well. +/// +/// This is essentially a [trait alias](https://github.com/rust-lang/rfcs/pull/1733). When trait +/// aliases are implemented, this may be replaced by one. +pub trait RuleType: Copy + Debug + Eq + Hash + Ord {} + +impl<T: Copy + Debug + Eq + Hash + Ord> RuleType for T {} diff --git a/vendor/pest/src/macros.rs b/vendor/pest/src/macros.rs new file mode 100644 index 000000000..01f410610 --- /dev/null +++ b/vendor/pest/src/macros.rs @@ -0,0 +1,455 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[doc(hidden)] +#[macro_export] +macro_rules! consumes_to { + ( $_rules:ident, $tokens:expr, [] ) => (); + ( $rules:ident, $tokens:expr, [ $name:ident ( $start:expr, $end:expr ) ] ) => { + let expected = format!("expected Start {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $start); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::Start { rule, pos } => { + let message = format!("{} but found Start {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $start { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + + let expected = format!("expected End {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $end); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::End { rule, pos } => { + let message = format!("{} but found End {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $end { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + }; + ( $rules:ident, $tokens:expr, [ $name:ident ( $start:expr, $end:expr ), + $( $names:ident $calls:tt ),* $(,)* ] ) => { + + let expected = format!("expected Start {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $start); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::Start { rule, pos } => { + let message = format!("{} but found Start {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $start { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + + let expected = format!("expected End {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $end); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::End { rule, pos } => { + let message = format!("{} but found End {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $end { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + + consumes_to!($rules, $tokens, [ $( $names $calls ),* ]); + }; + ( $rules:ident, $tokens:expr, [ $name:ident ( $start:expr, $end:expr, + [ $( $names:ident $calls:tt ),* $(,)* ] ) ] ) => { + let expected = format!("expected Start {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $start); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::Start { rule, pos } => { + let message = format!("{} but found Start {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $start { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + + consumes_to!($rules, $tokens, [ $( $names $calls ),* ]); + + let expected = format!("expected End {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $end); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::End { rule, pos } => { + let message = format!("{} but found End {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $end { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + }; + ( $rules:ident, $tokens:expr, [ $name:ident ( $start:expr, $end:expr, + [ $( $nested_names:ident $nested_calls:tt ),* + $(,)* ] ), + $( $names:ident $calls:tt ),* ] ) => { + + let expected = format!("expected Start {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $start); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::Start { rule, pos } => { + let message = format!("{} but found Start {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $start { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + + consumes_to!($rules, $tokens, [ $( $nested_names $nested_calls ),* ]); + + let expected = format!("expected End {{ rule: {:?}, pos: Position {{ pos: {} }} }}", + $rules::$name, $end); + match $tokens.next().expect(&format!("{} but found nothing", expected)) { + $crate::Token::End { rule, pos } => { + let message = format!("{} but found End {{ rule: {:?}, pos: Position {{ {} }} }}", + expected, rule, pos.pos()); + + if rule != $rules::$name || pos.pos() != $end { + panic!("{}", message); + } + }, + token => panic!("{}", format!("{} but found {:?}", expected, token)) + }; + + consumes_to!($rules, $tokens, [ $( $names $calls ),* ]); + }; +} + +/// Testing tool that compares produced tokens. +/// +/// This macro takes several arguments: +/// +/// * `parser` - name of the data structure implementing `Parser` +/// * `input` - input to be tested against +/// * `rule` - `Rule` which will be run +/// * `tokens` - token pairs of the form `name(start_pos, end_pos, [nested_child_tokens])` +/// +/// *Note:* `start_pos` and `end_pos` are byte positions. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] +/// # extern crate pest; +/// # use pest::Parser; +/// # use pest::error::Error; +/// # use pest::iterators::Pairs; +/// # fn main() { +/// # #[allow(non_camel_case_types)] +/// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +/// # enum Rule { +/// # a, +/// # b, +/// # c +/// # } +/// # +/// # struct AbcParser; +/// # +/// # impl Parser<Rule> for AbcParser { +/// # fn parse<'i>(_: Rule, input: &'i str) -> Result<Pairs<'i, Rule>, Error<Rule>> { +/// # pest::state(input, |state| { +/// # state.rule(Rule::a, |state| { +/// # state.skip(1).unwrap().rule(Rule::b, |state| { +/// # state.skip(1) +/// # }).unwrap().skip(1) +/// # }).and_then(|state| { +/// # state.skip(1).unwrap().rule(Rule::c, |state| { +/// # state.skip(1) +/// # }) +/// # }) +/// # }) +/// # } +/// # } +/// parses_to! { +/// parser: AbcParser, +/// input: "abcde", +/// rule: Rule::a, +/// tokens: [ +/// a(0, 3, [ +/// b(1, 2) +/// ]), +/// c(4, 5) +/// ] +/// }; +/// # } +/// ``` +#[macro_export] +macro_rules! parses_to { + ( parser: $parser:ident, input: $string:expr, rule: $rules:tt :: $rule:tt, + tokens: [ $( $names:ident $calls:tt ),* $(,)* ] ) => { + + #[allow(unused_mut)] + { + use $crate::Parser; + + let mut tokens = $parser::parse($rules::$rule, $string).unwrap().tokens(); + + consumes_to!($rules, &mut tokens, [ $( $names $calls ),* ]); + + let rest: Vec<_> = tokens.collect(); + + match rest.len() { + 0 => (), + 2 => { + let (first, second) = (&rest[0], &rest[1]); + + match (first, second) { + ( + &$crate::Token::Start { rule: ref first_rule, .. }, + &$crate::Token::End { rule: ref second_rule, .. } + ) => { + assert!( + format!("{:?}", first_rule) == "EOI", + format!("expected end of input, but found {:?}", rest) + ); + assert!( + format!("{:?}", second_rule) == "EOI", + format!("expected end of input, but found {:?}", rest) + ); + } + _ => panic!("expected end of input, but found {:?}", rest) + } + } + _ => panic!("expected end of input, but found {:?}", rest) + }; + } + }; +} + +/// Testing tool that compares produced errors. +/// +/// This macro takes several arguments: +/// +/// * `parser` - name of the data structure implementing `Parser` +/// * `input` - input to be tested against +/// * `rule` - `Rule` which will be run +/// * `positives` - positive `Rule` attempts that failed +/// * `negative` - negative `Rule` attempts that failed +/// * `pos` - byte position of failure +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] +/// # extern crate pest; +/// # use pest::Parser; +/// # use pest::error::Error; +/// # use pest::iterators::Pairs; +/// # fn main() { +/// # #[allow(non_camel_case_types)] +/// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +/// # enum Rule { +/// # a, +/// # b, +/// # c +/// # } +/// # +/// # struct AbcParser; +/// # +/// # impl Parser<Rule> for AbcParser { +/// # fn parse<'i>(_: Rule, input: &'i str) -> Result<Pairs<'i, Rule>, Error<Rule>> { +/// # pest::state(input, |state| { +/// # state.rule(Rule::a, |state| { +/// # state.skip(1).unwrap().rule(Rule::b, |s| { +/// # s.skip(1) +/// # }).unwrap().skip(1) +/// # }).and_then(|state| { +/// # state.skip(1).unwrap().rule(Rule::c, |s| { +/// # s.match_string("e") +/// # }) +/// # }) +/// # }) +/// # } +/// # } +/// fails_with! { +/// parser: AbcParser, +/// input: "abcdf", +/// rule: Rule::a, +/// positives: vec![Rule::c], +/// negatives: vec![], +/// pos: 4 +/// }; +/// # } +/// ``` +#[macro_export] +macro_rules! fails_with { + ( parser: $parser:ident, input: $string:expr, rule: $rules:tt :: $rule:tt, + positives: $positives:expr, negatives: $negatives:expr, pos: $pos:expr ) => { + #[allow(unused_mut)] + { + use $crate::Parser; + + let error = $parser::parse($rules::$rule, $string).unwrap_err(); + + match error.variant { + $crate::error::ErrorVariant::ParsingError { + positives, + negatives, + } => { + assert_eq!(positives, $positives); + assert_eq!(negatives, $negatives); + } + _ => unreachable!(), + }; + + match error.location { + $crate::error::InputLocation::Pos(pos) => assert_eq!(pos, $pos), + _ => unreachable!(), + } + } + }; +} + +#[cfg(test)] +pub mod tests { + use super::super::error::Error; + use super::super::iterators::Pairs; + use super::super::{state, Parser}; + + #[allow(non_camel_case_types)] + #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub enum Rule { + a, + b, + c, + } + + pub struct AbcParser; + + impl Parser<Rule> for AbcParser { + fn parse<'i>(_: Rule, input: &'i str) -> Result<Pairs<'i, Rule>, Error<Rule>> { + state(input, |state| { + state + .rule(Rule::a, |s| { + s.skip(1) + .unwrap() + .rule(Rule::b, |s| s.skip(1)) + .unwrap() + .skip(1) + }) + .and_then(|s| s.skip(1).unwrap().rule(Rule::c, |s| s.match_string("e"))) + }) + } + } + + #[test] + fn parses_to() { + parses_to! { + parser: AbcParser, + input: "abcde", + rule: Rule::a, + tokens: [ + a(0, 3, [ + b(1, 2), + ]), + c(4, 5) + ] + }; + } + + #[test] + #[should_panic] + fn missing_end() { + parses_to! { + parser: AbcParser, + input: "abcde", + rule: Rule::a, + tokens: [ + a(0, 3, [ + b(1, 2) + ]) + ] + }; + } + + #[test] + #[should_panic] + fn empty() { + parses_to! { + parser: AbcParser, + input: "abcde", + rule: Rule::a, + tokens: [] + }; + } + + #[test] + fn fails_with() { + fails_with! { + parser: AbcParser, + input: "abcdf", + rule: Rule::a, + positives: vec![Rule::c], + negatives: vec![], + pos: 4 + }; + } + + #[test] + #[should_panic] + fn wrong_positives() { + fails_with! { + parser: AbcParser, + input: "abcdf", + rule: Rule::a, + positives: vec![Rule::a], + negatives: vec![], + pos: 4 + }; + } + + #[test] + #[should_panic] + fn wrong_negatives() { + fails_with! { + parser: AbcParser, + input: "abcdf", + rule: Rule::a, + positives: vec![Rule::c], + negatives: vec![Rule::c], + pos: 4 + }; + } + + #[test] + #[should_panic] + fn wrong_pos() { + fails_with! { + parser: AbcParser, + input: "abcdf", + rule: Rule::a, + positives: vec![Rule::c], + negatives: vec![], + pos: 3 + }; + } +} diff --git a/vendor/pest/src/parser.rs b/vendor/pest/src/parser.rs new file mode 100644 index 000000000..a8792d152 --- /dev/null +++ b/vendor/pest/src/parser.rs @@ -0,0 +1,18 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use error::Error; +use iterators::Pairs; +use RuleType; + +/// A trait with a single method that parses strings. +pub trait Parser<R: RuleType> { + /// Parses a `&str` starting from `rule`. + fn parse(rule: R, input: &str) -> Result<Pairs<R>, Error<R>>; +} diff --git a/vendor/pest/src/parser_state.rs b/vendor/pest/src/parser_state.rs new file mode 100644 index 000000000..09bc92710 --- /dev/null +++ b/vendor/pest/src/parser_state.rs @@ -0,0 +1,1160 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::ops::Range; +use std::rc::Rc; + +use error::{Error, ErrorVariant}; +use iterators::{pairs, QueueableToken}; +use position::{self, Position}; +use span::Span; +use stack::Stack; +use RuleType; + +/// The current lookahead status of a [`ParserState`]. +/// +/// [`ParserState`]: struct.ParserState.html +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Lookahead { + Positive, + Negative, + None, +} + +/// The current atomicity of a [`ParserState`]. +/// +/// [`ParserState`]: struct.ParserState.html +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Atomicity { + Atomic, + CompoundAtomic, + NonAtomic, +} + +/// Type alias to simplify specifying the return value of chained closures. +pub type ParseResult<S> = Result<S, S>; + +/// Match direction for the stack. Used in `PEEK[a..b]`/`stack_match_peek_slice`. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum MatchDir { + BottomToTop, + TopToBottom, +} + +/// The complete state of a [`Parser`]. +/// +/// [`Parser`]: trait.Parser.html +#[derive(Debug)] +pub struct ParserState<'i, R: RuleType> { + position: Position<'i>, + queue: Vec<QueueableToken<R>>, + lookahead: Lookahead, + pos_attempts: Vec<R>, + neg_attempts: Vec<R>, + attempt_pos: usize, + atomicity: Atomicity, + stack: Stack<Span<'i>>, +} + +/// Creates a `ParserState` from a `&str`, supplying it to a closure `f`. +/// +/// # Examples +/// +/// ``` +/// # use pest; +/// let input = ""; +/// pest::state::<(), _>(input, |s| Ok(s)).unwrap(); +/// ``` +pub fn state<'i, R: RuleType, F>(input: &'i str, f: F) -> Result<pairs::Pairs<'i, R>, Error<R>> +where + F: FnOnce(Box<ParserState<'i, R>>) -> ParseResult<Box<ParserState<'i, R>>>, +{ + let state = ParserState::new(input); + + match f(state) { + Ok(state) => { + let len = state.queue.len(); + Ok(pairs::new(Rc::new(state.queue), input, 0, len)) + } + Err(mut state) => { + state.pos_attempts.sort(); + state.pos_attempts.dedup(); + state.neg_attempts.sort(); + state.neg_attempts.dedup(); + + Err(Error::new_from_pos( + ErrorVariant::ParsingError { + positives: state.pos_attempts.clone(), + negatives: state.neg_attempts.clone(), + }, + // TODO(performance): Guarantee state.attempt_pos is a valid position + position::Position::new(input, state.attempt_pos).unwrap(), + )) + } + } +} + +impl<'i, R: RuleType> ParserState<'i, R> { + /// Allocates a fresh `ParserState` object to the heap and returns the owned `Box`. This `Box` + /// will be passed from closure to closure based on the needs of the specified `Parser`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// let input = ""; + /// let state: Box<pest::ParserState<&str>> = pest::ParserState::new(input); + /// ``` + #[allow(clippy::new_ret_no_self)] + pub fn new(input: &'i str) -> Box<Self> { + Box::new(ParserState { + position: Position::from_start(input), + queue: vec![], + lookahead: Lookahead::None, + pos_attempts: vec![], + neg_attempts: vec![], + attempt_pos: 0, + atomicity: Atomicity::NonAtomic, + stack: Stack::new(), + }) + } + + /// Returns a reference to the current `Position` of the `ParserState`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let position = state.position(); + /// assert_eq!(position.pos(), 0); + /// ``` + pub fn position(&self) -> &Position<'i> { + &self.position + } + + /// Returns the current atomicity of the `ParserState`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # use pest::Atomicity; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let atomicity = state.atomicity(); + /// assert_eq!(atomicity, Atomicity::NonAtomic); + /// ``` + pub fn atomicity(&self) -> Atomicity { + self.atomicity + } + + /// Wrapper needed to generate tokens. This will associate the `R` type rule to the closure + /// meant to match the rule. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = "a"; + /// let pairs: Vec<_> = pest::state(input, |state| { + /// state.rule(Rule::a, |s| Ok(s)) + /// }).unwrap().collect(); + /// + /// assert_eq!(pairs.len(), 1); + /// ``` + #[inline] + pub fn rule<F>(mut self: Box<Self>, rule: R, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + let actual_pos = self.position.pos(); + let index = self.queue.len(); + + let (pos_attempts_index, neg_attempts_index) = if actual_pos == self.attempt_pos { + (self.pos_attempts.len(), self.neg_attempts.len()) + } else { + // Attempts have not been cleared yet since the attempt_pos is older. + (0, 0) + }; + + if self.lookahead == Lookahead::None && self.atomicity != Atomicity::Atomic { + // Pair's position will only be known after running the closure. + self.queue.push(QueueableToken::Start { + end_token_index: 0, + input_pos: actual_pos, + }); + } + + let attempts = self.attempts_at(actual_pos); + + let result = f(self); + + match result { + Ok(mut new_state) => { + if new_state.lookahead == Lookahead::Negative { + new_state.track( + rule, + actual_pos, + pos_attempts_index, + neg_attempts_index, + attempts, + ); + } + + if new_state.lookahead == Lookahead::None + && new_state.atomicity != Atomicity::Atomic + { + // Storing the pair's index in the first token that was added before the closure was + // run. + let new_index = new_state.queue.len(); + match new_state.queue[index] { + QueueableToken::Start { + ref mut end_token_index, + .. + } => *end_token_index = new_index, + _ => unreachable!(), + }; + + let new_pos = new_state.position.pos(); + + new_state.queue.push(QueueableToken::End { + start_token_index: index, + rule, + input_pos: new_pos, + }); + } + + Ok(new_state) + } + Err(mut new_state) => { + if new_state.lookahead != Lookahead::Negative { + new_state.track( + rule, + actual_pos, + pos_attempts_index, + neg_attempts_index, + attempts, + ); + } + + if new_state.lookahead == Lookahead::None + && new_state.atomicity != Atomicity::Atomic + { + new_state.queue.truncate(index); + } + + Err(new_state) + } + } + } + + fn attempts_at(&self, pos: usize) -> usize { + if self.attempt_pos == pos { + self.pos_attempts.len() + self.neg_attempts.len() + } else { + 0 + } + } + + fn track( + &mut self, + rule: R, + pos: usize, + pos_attempts_index: usize, + neg_attempts_index: usize, + prev_attempts: usize, + ) { + if self.atomicity == Atomicity::Atomic { + return; + } + + // If nested rules made no progress, there is no use to report them; it's only useful to + // track the current rule, the exception being when only one attempt has been made during + // the children rules. + let curr_attempts = self.attempts_at(pos); + if curr_attempts > prev_attempts && curr_attempts - prev_attempts == 1 { + return; + } + + if pos == self.attempt_pos { + self.pos_attempts.truncate(pos_attempts_index); + self.neg_attempts.truncate(neg_attempts_index); + } + + if pos > self.attempt_pos { + self.pos_attempts.clear(); + self.neg_attempts.clear(); + self.attempt_pos = pos; + } + + let attempts = if self.lookahead != Lookahead::Negative { + &mut self.pos_attempts + } else { + &mut self.neg_attempts + }; + + if pos == self.attempt_pos { + attempts.push(rule); + } + } + + /// Starts a sequence of transformations provided by `f` from the `Box<ParserState>`. Returns + /// the same `Result` returned by `f` in the case of an `Ok`, or `Err` with the current + /// `Box<ParserState>` otherwise. + /// + /// This method is useful to parse sequences that only match together which usually come in the + /// form of chained `Result`s with + /// [`Result::and_then`](https://doc.rust-lang.org/std/result/enum.Result.html#method.and_then). + /// + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = "a"; + /// let pairs: Vec<_> = pest::state(input, |state| { + /// state.sequence(|s| { + /// s.rule(Rule::a, |s| Ok(s)).and_then(|s| { + /// s.match_string("b") + /// }) + /// }).or_else(|s| { + /// Ok(s) + /// }) + /// }).unwrap().collect(); + /// + /// assert_eq!(pairs.len(), 0); + /// ``` + #[inline] + pub fn sequence<F>(self: Box<Self>, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + let token_index = self.queue.len(); + let initial_pos = self.position.clone(); + + let result = f(self); + + match result { + Ok(new_state) => Ok(new_state), + Err(mut new_state) => { + // Restore the initial position and truncate the token queue. + new_state.position = initial_pos; + new_state.queue.truncate(token_index); + Err(new_state) + } + } + } + + /// Repeatedly applies the transformation provided by `f` from the `Box<ParserState>`. Returns + /// `Ok` with the updated `Box<ParserState>` returned by `f` wrapped up in an `Err`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "aab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.repeat(|s| { + /// s.match_string("a") + /// }); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 2); + /// + /// state = pest::ParserState::new(input); + /// result = state.repeat(|s| { + /// s.match_string("b") + /// }); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 0); + /// ``` + #[inline] + pub fn repeat<F>(self: Box<Self>, mut f: F) -> ParseResult<Box<Self>> + where + F: FnMut(Box<Self>) -> ParseResult<Box<Self>>, + { + let mut result = f(self); + + loop { + match result { + Ok(state) => result = f(state), + Err(state) => return Ok(state), + }; + } + } + + /// Optionally applies the transformation provided by `f` from the `Box<ParserState>`. Returns + /// `Ok` with the updated `Box<ParserState>` returned by `f` regardless of the `Result`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// ab + /// } + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let result = state.optional(|s| { + /// s.match_string("ab") + /// }); + /// assert!(result.is_ok()); + /// + /// state = pest::ParserState::new(input); + /// let result = state.optional(|s| { + /// s.match_string("ac") + /// }); + /// assert!(result.is_ok()); + /// ``` + #[inline] + pub fn optional<F>(self: Box<Self>, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + match f(self) { + Ok(state) | Err(state) => Ok(state), + } + } + + /// Attempts to match a single character based on a filter function. Returns `Ok` with the + /// updated `Box<ParserState>` if successful, or `Err` with the updated `Box<ParserState>` + /// otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let result = state.match_char_by(|c| c.is_ascii()); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 1); + /// + /// let input = "❤"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let result = state.match_char_by(|c| c.is_ascii()); + /// assert!(result.is_err()); + /// assert_eq!(result.unwrap_err().position().pos(), 0); + /// ``` + #[inline] + pub fn match_char_by<F>(mut self: Box<Self>, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(char) -> bool, + { + if self.position.match_char_by(f) { + Ok(self) + } else { + Err(self) + } + } + + /// Attempts to match the given string. Returns `Ok` with the updated `Box<ParserState>` if + /// successful, or `Err` with the updated `Box<ParserState>` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.match_string("ab"); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 2); + /// + /// state = pest::ParserState::new(input); + /// result = state.match_string("ac"); + /// assert!(result.is_err()); + /// assert_eq!(result.unwrap_err().position().pos(), 0); + /// ``` + #[inline] + pub fn match_string(mut self: Box<Self>, string: &str) -> ParseResult<Box<Self>> { + if self.position.match_string(string) { + Ok(self) + } else { + Err(self) + } + } + + /// Attempts to case-insensitively match the given string. Returns `Ok` with the updated + /// `Box<ParserState>` if successful, or `Err` with the updated `Box<ParserState>` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.match_insensitive("AB"); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 2); + /// + /// state = pest::ParserState::new(input); + /// result = state.match_insensitive("AC"); + /// assert!(result.is_err()); + /// assert_eq!(result.unwrap_err().position().pos(), 0); + /// ``` + #[inline] + pub fn match_insensitive(mut self: Box<Self>, string: &str) -> ParseResult<Box<Self>> { + if self.position.match_insensitive(string) { + Ok(self) + } else { + Err(self) + } + } + + /// Attempts to match a single character from the given range. Returns `Ok` with the updated + /// `Box<ParserState>` if successful, or `Err` with the updated `Box<ParserState>` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.match_range('a'..'z'); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 1); + /// + /// state = pest::ParserState::new(input); + /// result = state.match_range('A'..'Z'); + /// assert!(result.is_err()); + /// assert_eq!(result.unwrap_err().position().pos(), 0); + /// ``` + #[inline] + pub fn match_range(mut self: Box<Self>, range: Range<char>) -> ParseResult<Box<Self>> { + if self.position.match_range(range) { + Ok(self) + } else { + Err(self) + } + } + + /// Attempts to skip `n` characters forward. Returns `Ok` with the updated `Box<ParserState>` + /// if successful, or `Err` with the updated `Box<ParserState>` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.skip(1); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 1); + /// + /// state = pest::ParserState::new(input); + /// result = state.skip(3); + /// assert!(result.is_err()); + /// assert_eq!(result.unwrap_err().position().pos(), 0); + /// ``` + #[inline] + pub fn skip(mut self: Box<Self>, n: usize) -> ParseResult<Box<Self>> { + if self.position.skip(n) { + Ok(self) + } else { + Err(self) + } + } + + /// Attempts to skip forward until one of the given strings is found. Returns `Ok` with the + /// updated `Box<ParserState>` whether or not one of the strings is found. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "abcd"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.skip_until(&["c", "d"]); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 2); + /// ``` + #[inline] + pub fn skip_until(mut self: Box<Self>, strings: &[&str]) -> ParseResult<Box<Self>> { + self.position.skip_until(strings); + Ok(self) + } + + /// Attempts to match the start of the input. Returns `Ok` with the current `Box<ParserState>` + /// if the parser has not yet advanced, or `Err` with the current `Box<ParserState>` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.start_of_input(); + /// assert!(result.is_ok()); + /// + /// state = pest::ParserState::new(input); + /// state = state.match_string("ab").unwrap(); + /// result = state.start_of_input(); + /// assert!(result.is_err()); + /// ``` + #[inline] + pub fn start_of_input(self: Box<Self>) -> ParseResult<Box<Self>> { + if self.position.at_start() { + Ok(self) + } else { + Err(self) + } + } + + /// Attempts to match the end of the input. Returns `Ok` with the current `Box<ParserState>` if + /// there is no input remaining, or `Err` with the current `Box<ParserState>` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.end_of_input(); + /// assert!(result.is_err()); + /// + /// state = pest::ParserState::new(input); + /// state = state.match_string("ab").unwrap(); + /// result = state.end_of_input(); + /// assert!(result.is_ok()); + /// ``` + #[inline] + pub fn end_of_input(self: Box<Self>) -> ParseResult<Box<Self>> { + if self.position.at_end() { + Ok(self) + } else { + Err(self) + } + } + + /// Starts a lookahead transformation provided by `f` from the `Box<ParserState>`. It returns + /// `Ok` with the current `Box<ParserState>` if `f` also returns an `Ok`, or `Err` with the current + /// `Box<ParserState>` otherwise. If `is_positive` is `false`, it swaps the `Ok` and `Err` + /// together, negating the `Result`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = "a"; + /// let pairs: Vec<_> = pest::state(input, |state| { + /// state.lookahead(true, |state| { + /// state.rule(Rule::a, |s| Ok(s)) + /// }) + /// }).unwrap().collect(); + /// + /// assert_eq!(pairs.len(), 0); + /// ``` + #[inline] + pub fn lookahead<F>(mut self: Box<Self>, is_positive: bool, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + let initial_lookahead = self.lookahead; + + self.lookahead = if is_positive { + match initial_lookahead { + Lookahead::None | Lookahead::Positive => Lookahead::Positive, + Lookahead::Negative => Lookahead::Negative, + } + } else { + match initial_lookahead { + Lookahead::None | Lookahead::Positive => Lookahead::Negative, + Lookahead::Negative => Lookahead::Positive, + } + }; + + let initial_pos = self.position.clone(); + + let result = f(self.checkpoint()); + + let result_state = match result { + Ok(mut new_state) => { + new_state.position = initial_pos; + new_state.lookahead = initial_lookahead; + Ok(new_state.restore()) + } + Err(mut new_state) => { + new_state.position = initial_pos; + new_state.lookahead = initial_lookahead; + Err(new_state.restore()) + } + }; + + if is_positive { + result_state + } else { + match result_state { + Ok(state) => Err(state), + Err(state) => Ok(state), + } + } + } + + /// Transformation which stops `Token`s from being generated according to `is_atomic`. + /// + /// # Examples + /// + /// ``` + /// # use pest::{self, Atomicity}; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule { + /// a + /// } + /// + /// let input = "a"; + /// let pairs: Vec<_> = pest::state(input, |state| { + /// state.atomic(Atomicity::Atomic, |s| { + /// s.rule(Rule::a, |s| Ok(s)) + /// }) + /// }).unwrap().collect(); + /// + /// assert_eq!(pairs.len(), 0); + /// ``` + #[inline] + pub fn atomic<F>(mut self: Box<Self>, atomicity: Atomicity, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + let initial_atomicity = self.atomicity; + let should_toggle = self.atomicity != atomicity; + + if should_toggle { + self.atomicity = atomicity; + } + + let result = f(self); + + match result { + Ok(mut new_state) => { + if should_toggle { + new_state.atomicity = initial_atomicity; + } + Ok(new_state) + } + Err(mut new_state) => { + if should_toggle { + new_state.atomicity = initial_atomicity; + } + Err(new_state) + } + } + } + + /// Evaluates the result of closure `f` and pushes the span of the input consumed from before + /// `f` is called to after `f` is called to the stack. Returns `Ok(Box<ParserState>)` if `f` is + /// called successfully, or `Err(Box<ParserState>)` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.stack_push(|state| state.match_string("a")); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 1); + /// ``` + #[inline] + pub fn stack_push<F>(self: Box<Self>, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + let start = self.position.clone(); + + let result = f(self); + + match result { + Ok(mut state) => { + let end = state.position.clone(); + state.stack.push(start.span(&end)); + Ok(state) + } + Err(state) => Err(state), + } + } + + /// Peeks the top of the stack and attempts to match the string. Returns `Ok(Box<ParserState>)` + /// if the string is matched successfully, or `Err(Box<ParserState>)` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "aa"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.stack_push(|state| state.match_string("a")).and_then( + /// |state| state.stack_peek() + /// ); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 2); + /// ``` + #[inline] + pub fn stack_peek(self: Box<Self>) -> ParseResult<Box<Self>> { + let string = self + .stack + .peek() + .expect("peek was called on empty stack") + .as_str(); + self.match_string(string) + } + + /// Pops the top of the stack and attempts to match the string. Returns `Ok(Box<ParserState>)` + /// if the string is matched successfully, or `Err(Box<ParserState>)` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "aa"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.stack_push(|state| state.match_string("a")).and_then( + /// |state| state.stack_pop() + /// ); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 2); + /// ``` + #[inline] + pub fn stack_pop(mut self: Box<Self>) -> ParseResult<Box<Self>> { + let string = self + .stack + .pop() + .expect("pop was called on empty stack") + .as_str(); + self.match_string(string) + } + + /// Matches part of the state of the stack. + /// + /// # Examples + /// + /// ``` + /// # use pest::{self, MatchDir}; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "abcd cd cb"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state + /// .stack_push(|state| state.match_string("a")) + /// .and_then(|state| state.stack_push(|state| state.match_string("b"))) + /// .and_then(|state| state.stack_push(|state| state.match_string("c"))) + /// .and_then(|state| state.stack_push(|state| state.match_string("d"))) + /// .and_then(|state| state.match_string(" ")) + /// .and_then(|state| state.stack_match_peek_slice(2, None, MatchDir::BottomToTop)) + /// .and_then(|state| state.match_string(" ")) + /// .and_then(|state| state.stack_match_peek_slice(1, Some(-1), MatchDir::TopToBottom)); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 10); + /// ``` + #[inline] + pub fn stack_match_peek_slice( + mut self: Box<Self>, + start: i32, + end: Option<i32>, + match_dir: MatchDir, + ) -> ParseResult<Box<Self>> { + let range = match constrain_idxs(start, end, self.stack.len()) { + Some(r) => r, + None => return Err(self), + }; + // return true if an empty sequence is requested + if range.end <= range.start { + return Ok(self); + } + + let mut position = self.position.clone(); + let result = { + let mut iter_b2t = self.stack[range].iter(); + let matcher = |span: &Span| position.match_string(span.as_str()); + match match_dir { + MatchDir::BottomToTop => iter_b2t.all(matcher), + MatchDir::TopToBottom => iter_b2t.rev().all(matcher), + } + }; + if result { + self.position = position; + Ok(self) + } else { + Err(self) + } + } + + /// Matches the full state of the stack. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "abba"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state + /// .stack_push(|state| state.match_string("a")) + /// .and_then(|state| { state.stack_push(|state| state.match_string("b")) }) + /// .and_then(|state| state.stack_match_peek()); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 4); + /// ``` + #[inline] + pub fn stack_match_peek(self: Box<Self>) -> ParseResult<Box<Self>> { + self.stack_match_peek_slice(0, None, MatchDir::TopToBottom) + } + + /// Matches the full state of the stack. This method will clear the stack as it evaluates. + /// + /// # Examples + /// + /// ``` + /// /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "aaaa"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.stack_push(|state| state.match_string("a")).and_then(|state| { + /// state.stack_push(|state| state.match_string("a")) + /// }).and_then(|state| state.stack_match_peek()); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 4); + /// ``` + #[inline] + pub fn stack_match_pop(mut self: Box<Self>) -> ParseResult<Box<Self>> { + let mut position = self.position.clone(); + let mut result = true; + while let Some(span) = self.stack.pop() { + result = position.match_string(span.as_str()); + if !result { + break; + } + } + + if result { + self.position = position; + Ok(self) + } else { + Err(self) + } + } + + /// Drops the top of the stack. Returns `Ok(Box<ParserState>)` if there was a value to drop, or + /// `Err(Box<ParserState>)` otherwise. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "aa"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.stack_push(|state| state.match_string("a")).and_then( + /// |state| state.stack_drop() + /// ); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().pos(), 1); + /// ``` + #[inline] + pub fn stack_drop(mut self: Box<Self>) -> ParseResult<Box<Self>> { + match self.stack.pop() { + Some(_) => Ok(self), + None => Err(self), + } + } + + /// Restores the original state of the `ParserState` when `f` returns an `Err`. Currently, + /// this method only restores the stack. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "ab"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.restore_on_err(|state| state.stack_push(|state| + /// state.match_string("a")).and_then(|state| state.match_string("a")) + /// ); + /// + /// assert!(result.is_err()); + /// + /// // Since the the rule doesn't match, the "a" pushed to the stack will be removed. + /// let catch_panic = std::panic::catch_unwind(|| result.unwrap_err().stack_pop()); + /// assert!(catch_panic.is_err()); + /// ``` + #[inline] + pub fn restore_on_err<F>(self: Box<Self>, f: F) -> ParseResult<Box<Self>> + where + F: FnOnce(Box<Self>) -> ParseResult<Box<Self>>, + { + match f(self.checkpoint()) { + Ok(state) => Ok(state.checkpoint_ok()), + Err(state) => Err(state.restore()), + } + } + + // Mark the current state as a checkpoint and return the `Box`. + #[inline] + pub(crate) fn checkpoint(mut self: Box<Self>) -> Box<Self> { + self.stack.snapshot(); + self + } + + // The checkpoint was cleared successfully + // so remove it without touching other stack state. + #[inline] + pub(crate) fn checkpoint_ok(mut self: Box<Self>) -> Box<Self> { + self.stack.clear_snapshot(); + self + } + + // Restore the current state to the most recent checkpoint. + #[inline] + pub(crate) fn restore(mut self: Box<Self>) -> Box<Self> { + self.stack.restore(); + self + } +} + +fn constrain_idxs(start: i32, end: Option<i32>, len: usize) -> Option<Range<usize>> { + let start_norm = normalize_index(start, len)?; + let end_norm = end.map_or(Some(len), |e| normalize_index(e, len))?; + Some(start_norm..end_norm) +} + +/// Normalizes the index using its sequence’s length. +/// Returns `None` if the normalized index is OOB. +fn normalize_index(i: i32, len: usize) -> Option<usize> { + if i > len as i32 { + None + } else if i >= 0 { + Some(i as usize) + } else { + let real_i = len as i32 + i; + if real_i >= 0 { + Some(real_i as usize) + } else { + None + } + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn normalize_index_pos() { + assert_eq!(normalize_index(4, 6), Some(4)); + assert_eq!(normalize_index(5, 5), Some(5)); + assert_eq!(normalize_index(6, 3), None); + } + + #[test] + fn normalize_index_neg() { + assert_eq!(normalize_index(-4, 6), Some(2)); + assert_eq!(normalize_index(-5, 5), Some(0)); + assert_eq!(normalize_index(-6, 3), None); + } +} diff --git a/vendor/pest/src/position.rs b/vendor/pest/src/position.rs new file mode 100644 index 000000000..76e3383ba --- /dev/null +++ b/vendor/pest/src/position.rs @@ -0,0 +1,619 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::cmp::Ordering; +use std::fmt; +use std::hash::{Hash, Hasher}; +use std::ops::Range; +use std::ptr; +use std::str; + +use span; + +/// A cursor position in a `&str` which provides useful methods to manually parse that string. +#[derive(Clone)] +pub struct Position<'i> { + input: &'i str, + /// # Safety: + /// + /// `input[pos..]` must be a valid codepoint boundary (should not panic when indexing thus). + pos: usize, +} + +impl<'i> Position<'i> { + /// Create a new `Position` without checking invariants. (Checked with `debug_assertions`.) + /// + /// # Safety: + /// + /// `input[pos..]` must be a valid codepoint boundary (should not panic when indexing thus). + pub(crate) unsafe fn new_unchecked(input: &str, pos: usize) -> Position { + debug_assert!(input.get(pos..).is_some()); + Position { input, pos } + } + + /// Attempts to create a new `Position` at the given position. If the specified position is + /// an invalid index, or the specified position is not a valid UTF8 boundary, then None is + /// returned. + /// + /// # Examples + /// ``` + /// # use pest::Position; + /// let cheart = '💖'; + /// let heart = "💖"; + /// assert_eq!(Position::new(heart, 1), None); + /// assert_ne!(Position::new(heart, cheart.len_utf8()), None); + /// ``` + #[allow(clippy::new_ret_no_self)] + pub fn new(input: &str, pos: usize) -> Option<Position> { + input.get(pos..).map(|_| Position { input, pos }) + } + + /// Creates a `Position` at the start of a `&str`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let start = Position::from_start(""); + /// assert_eq!(start.pos(), 0); + /// ``` + #[inline] + pub fn from_start(input: &'i str) -> Position<'i> { + // Position 0 is always safe because it's always a valid UTF-8 border. + Position { input, pos: 0 } + } + + /// Returns the byte position of this `Position` as a `usize`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let mut start = Position::from_start(input); + /// + /// assert_eq!(start.pos(), 0); + /// ``` + #[inline] + pub fn pos(&self) -> usize { + self.pos + } + + /// Creates a `Span` from two `Position`s. + /// + /// # Panics + /// + /// Panics if the positions come from different inputs. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let start = Position::from_start(input); + /// let span = start.span(&start.clone()); + /// + /// assert_eq!(span.start(), 0); + /// assert_eq!(span.end(), 0); + /// ``` + #[inline] + pub fn span(&self, other: &Position<'i>) -> span::Span<'i> { + if ptr::eq(self.input, other.input) + /* && self.input.get(self.pos..other.pos).is_some() */ + { + // This is safe because the pos field of a Position should always be a valid str index. + unsafe { span::Span::new_unchecked(self.input, self.pos, other.pos) } + } else { + // TODO: maybe a panic if self.pos < other.pos + panic!("span created from positions from different inputs") + } + } + + /// Returns the line and column number of this `Position`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "\na"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.match_string("\na"); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().line_col(), (2, 2)); + /// ``` + #[inline] + pub fn line_col(&self) -> (usize, usize) { + if self.pos > self.input.len() { + panic!("position out of bounds"); + } + + let mut pos = self.pos; + // Position's pos is always a UTF-8 border. + let slice = &self.input[..pos]; + let mut chars = slice.chars().peekable(); + + let mut line_col = (1, 1); + + while pos != 0 { + match chars.next() { + Some('\r') => { + if let Some(&'\n') = chars.peek() { + chars.next(); + + if pos == 1 { + pos -= 1; + } else { + pos -= 2; + } + + line_col = (line_col.0 + 1, 1); + } else { + pos -= 1; + line_col = (line_col.0, line_col.1 + 1); + } + } + Some('\n') => { + pos -= 1; + line_col = (line_col.0 + 1, 1); + } + Some(c) => { + pos -= c.len_utf8(); + line_col = (line_col.0, line_col.1 + 1); + } + None => unreachable!(), + } + } + + line_col + } + + /// Returns the entire line of the input that contains this `Position`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "\na"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input); + /// let mut result = state.match_string("\na"); + /// assert!(result.is_ok()); + /// assert_eq!(result.unwrap().position().line_of(), "a"); + /// ``` + #[inline] + pub fn line_of(&self) -> &'i str { + if self.pos > self.input.len() { + panic!("position out of bounds"); + }; + // Safe since start and end can only be valid UTF-8 borders. + &self.input[self.find_line_start()..self.find_line_end()] + } + + pub(crate) fn find_line_start(&self) -> usize { + if self.input.is_empty() { + return 0; + }; + // Position's pos is always a UTF-8 border. + let start = self + .input + .char_indices() + .rev() + .skip_while(|&(i, _)| i >= self.pos) + .find(|&(_, c)| c == '\n'); + match start { + Some((i, _)) => i + 1, + None => 0, + } + } + + pub(crate) fn find_line_end(&self) -> usize { + if self.input.is_empty() { + 0 + } else if self.pos == self.input.len() - 1 { + self.input.len() + } else { + // Position's pos is always a UTF-8 border. + let end = self + .input + .char_indices() + .skip_while(|&(i, _)| i < self.pos) + .find(|&(_, c)| c == '\n'); + match end { + Some((i, _)) => i + 1, + None => self.input.len(), + } + } + } + + /// Returns `true` when the `Position` points to the start of the input `&str`. + #[inline] + pub(crate) fn at_start(&self) -> bool { + self.pos == 0 + } + + /// Returns `true` when the `Position` points to the end of the input `&str`. + #[inline] + pub(crate) fn at_end(&self) -> bool { + self.pos == self.input.len() + } + + /// Skips `n` `char`s from the `Position` and returns `true` if the skip was possible or `false` + /// otherwise. If the return value is `false`, `pos` will not be updated. + #[inline] + pub(crate) fn skip(&mut self, n: usize) -> bool { + let skipped = { + let mut len = 0; + // Position's pos is always a UTF-8 border. + let mut chars = (&self.input[self.pos..]).chars(); + for _ in 0..n { + if let Some(c) = chars.next() { + len += c.len_utf8(); + } else { + return false; + } + } + len + }; + + self.pos += skipped; + true + } + + /// Goes back `n` `char`s from the `Position` and returns `true` if the skip was possible or `false` + /// otherwise. If the return value is `false`, `pos` will not be updated. + #[inline] + pub(crate) fn skip_back(&mut self, n: usize) -> bool { + let skipped = { + let mut len = 0; + // Position's pos is always a UTF-8 border. + let mut chars = (&self.input[..self.pos]).chars().rev(); + for _ in 0..n { + if let Some(c) = chars.next() { + len += c.len_utf8(); + } else { + return false; + } + } + len + }; + + self.pos -= skipped; + true + } + + /// Skips until one of the given `strings` is found. If none of the `strings` can be found, + /// this function will return `false` but its `pos` will *still* be updated. + #[inline] + pub(crate) fn skip_until(&mut self, strings: &[&str]) -> bool { + for from in self.pos..self.input.len() { + let bytes = if let Some(string) = self.input.get(from..) { + string.as_bytes() + } else { + continue; + }; + + for slice in strings.iter() { + let to = slice.len(); + if Some(slice.as_bytes()) == bytes.get(0..to) { + self.pos = from; + return true; + } + } + } + + self.pos = self.input.len(); + false + } + + /// Matches the char at the `Position` against a filter function and returns `true` if a match + /// was made. If no match was made, returns `false` and `pos` will not be updated. + #[inline] + pub(crate) fn match_char_by<F>(&mut self, f: F) -> bool + where + F: FnOnce(char) -> bool, + { + if let Some(c) = (&self.input[self.pos..]).chars().next() { + if f(c) { + self.pos += c.len_utf8(); + true + } else { + false + } + } else { + false + } + } + + /// Matches `string` from the `Position` and returns `true` if a match was made or `false` + /// otherwise. If no match was made, `pos` will not be updated. + #[inline] + pub(crate) fn match_string(&mut self, string: &str) -> bool { + let to = self.pos + string.len(); + + if Some(string.as_bytes()) == self.input.as_bytes().get(self.pos..to) { + self.pos = to; + true + } else { + false + } + } + + /// Case-insensitively matches `string` from the `Position` and returns `true` if a match was + /// made or `false` otherwise. If no match was made, `pos` will not be updated. + #[inline] + pub(crate) fn match_insensitive(&mut self, string: &str) -> bool { + let matched = { + let slice = &self.input[self.pos..]; + if let Some(slice) = slice.get(0..string.len()) { + slice.eq_ignore_ascii_case(string) + } else { + false + } + }; + + if matched { + self.pos += string.len(); + true + } else { + false + } + } + + /// Matches `char` `range` from the `Position` and returns `true` if a match was made or `false` + /// otherwise. If no match was made, `pos` will not be updated. + #[inline] + pub(crate) fn match_range(&mut self, range: Range<char>) -> bool { + if let Some(c) = (&self.input[self.pos..]).chars().next() { + if range.start <= c && c <= range.end { + self.pos += c.len_utf8(); + return true; + } + } + + false + } +} + +impl<'i> fmt::Debug for Position<'i> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Position").field("pos", &self.pos).finish() + } +} + +impl<'i> PartialEq for Position<'i> { + fn eq(&self, other: &Position<'i>) -> bool { + ptr::eq(self.input, other.input) && self.pos == other.pos + } +} + +impl<'i> Eq for Position<'i> {} + +impl<'i> PartialOrd for Position<'i> { + fn partial_cmp(&self, other: &Position<'i>) -> Option<Ordering> { + if ptr::eq(self.input, other.input) { + self.pos.partial_cmp(&other.pos) + } else { + None + } + } +} + +impl<'i> Ord for Position<'i> { + fn cmp(&self, other: &Position<'i>) -> Ordering { + self.partial_cmp(other) + .expect("cannot compare positions from different strs") + } +} + +impl<'i> Hash for Position<'i> { + fn hash<H: Hasher>(&self, state: &mut H) { + (self.input as *const str).hash(state); + self.pos.hash(state); + } +} + +#[cfg(test)] +mod tests { + use std::collections::HashSet; + + use super::*; + + #[test] + fn empty() { + let input = ""; + assert_eq!(Position::new(input, 0).unwrap().match_string(""), true); + assert_eq!(!Position::new(input, 0).unwrap().match_string("a"), true); + } + + #[test] + fn parts() { + let input = "asdasdf"; + + assert_eq!(Position::new(input, 0).unwrap().match_string("asd"), true); + assert_eq!(Position::new(input, 3).unwrap().match_string("asdf"), true); + } + + #[test] + fn line_col() { + let input = "a\rb\nc\r\nd嗨"; + + assert_eq!(Position::new(input, 0).unwrap().line_col(), (1, 1)); + assert_eq!(Position::new(input, 1).unwrap().line_col(), (1, 2)); + assert_eq!(Position::new(input, 2).unwrap().line_col(), (1, 3)); + assert_eq!(Position::new(input, 3).unwrap().line_col(), (1, 4)); + assert_eq!(Position::new(input, 4).unwrap().line_col(), (2, 1)); + assert_eq!(Position::new(input, 5).unwrap().line_col(), (2, 2)); + assert_eq!(Position::new(input, 6).unwrap().line_col(), (2, 3)); + assert_eq!(Position::new(input, 7).unwrap().line_col(), (3, 1)); + assert_eq!(Position::new(input, 8).unwrap().line_col(), (3, 2)); + assert_eq!(Position::new(input, 11).unwrap().line_col(), (3, 3)); + } + + #[test] + fn line_of() { + let input = "a\rb\nc\r\nd嗨"; + + assert_eq!(Position::new(input, 0).unwrap().line_of(), "a\rb\n"); + assert_eq!(Position::new(input, 1).unwrap().line_of(), "a\rb\n"); + assert_eq!(Position::new(input, 2).unwrap().line_of(), "a\rb\n"); + assert_eq!(Position::new(input, 3).unwrap().line_of(), "a\rb\n"); + assert_eq!(Position::new(input, 4).unwrap().line_of(), "c\r\n"); + assert_eq!(Position::new(input, 5).unwrap().line_of(), "c\r\n"); + assert_eq!(Position::new(input, 6).unwrap().line_of(), "c\r\n"); + assert_eq!(Position::new(input, 7).unwrap().line_of(), "d嗨"); + assert_eq!(Position::new(input, 8).unwrap().line_of(), "d嗨"); + assert_eq!(Position::new(input, 11).unwrap().line_of(), "d嗨"); + } + + #[test] + fn line_of_empty() { + let input = ""; + + assert_eq!(Position::new(input, 0).unwrap().line_of(), ""); + } + + #[test] + fn line_of_new_line() { + let input = "\n"; + + assert_eq!(Position::new(input, 0).unwrap().line_of(), "\n"); + } + + #[test] + fn line_of_between_new_line() { + let input = "\n\n"; + + assert_eq!(Position::new(input, 1).unwrap().line_of(), "\n"); + } + + fn measure_skip(input: &str, pos: usize, n: usize) -> Option<usize> { + let mut p = Position::new(input, pos).unwrap(); + if p.skip(n) { + Some(p.pos - pos) + } else { + None + } + } + + #[test] + fn skip_empty() { + let input = ""; + + assert_eq!(measure_skip(input, 0, 0), Some(0)); + assert_eq!(measure_skip(input, 0, 1), None); + } + + #[test] + fn skip() { + let input = "d嗨"; + + assert_eq!(measure_skip(input, 0, 0), Some(0)); + assert_eq!(measure_skip(input, 0, 1), Some(1)); + assert_eq!(measure_skip(input, 1, 1), Some(3)); + } + + #[test] + fn skip_until() { + let input = "ab ac"; + let pos = Position::from_start(input); + + let mut test_pos = pos.clone(); + test_pos.skip_until(&["a", "b"]); + assert_eq!(test_pos.pos(), 0); + + test_pos = pos.clone(); + test_pos.skip_until(&["b"]); + assert_eq!(test_pos.pos(), 1); + + test_pos = pos.clone(); + test_pos.skip_until(&["ab"]); + assert_eq!(test_pos.pos(), 0); + + test_pos = pos.clone(); + test_pos.skip_until(&["ac", "z"]); + assert_eq!(test_pos.pos(), 3); + + test_pos = pos.clone(); + assert!(!test_pos.skip_until(&["z"])); + assert_eq!(test_pos.pos(), 5); + } + + #[test] + fn match_range() { + let input = "b"; + + assert_eq!(Position::new(input, 0).unwrap().match_range('a'..'c'), true); + assert_eq!(Position::new(input, 0).unwrap().match_range('b'..'b'), true); + assert_eq!( + !Position::new(input, 0).unwrap().match_range('a'..'a'), + true + ); + assert_eq!( + !Position::new(input, 0).unwrap().match_range('c'..'c'), + true + ); + assert_eq!( + Position::new(input, 0).unwrap().match_range('a'..'嗨'), + true + ); + } + + #[test] + fn match_insensitive() { + let input = "AsdASdF"; + + assert_eq!( + Position::new(input, 0).unwrap().match_insensitive("asd"), + true + ); + assert_eq!( + Position::new(input, 3).unwrap().match_insensitive("asdf"), + true + ); + } + + #[test] + fn cmp() { + let input = "a"; + let start = Position::from_start(input); + let mut end = start.clone(); + + assert!(end.skip(1)); + let result = start.cmp(&end); + + assert_eq!(result, Ordering::Less); + } + + #[test] + #[should_panic] + fn cmp_panic() { + let input1 = "a"; + let input2 = "b"; + let pos1 = Position::from_start(input1); + let pos2 = Position::from_start(input2); + + pos1.cmp(&pos2); + } + + #[test] + fn hash() { + let input = "a"; + let start = Position::from_start(input); + let mut positions = HashSet::new(); + + positions.insert(start); + } +} diff --git a/vendor/pest/src/prec_climber.rs b/vendor/pest/src/prec_climber.rs new file mode 100644 index 000000000..d8bf0a08a --- /dev/null +++ b/vendor/pest/src/prec_climber.rs @@ -0,0 +1,233 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +//! Constructs useful in infix operator parsing with the precedence climbing method. + +use std::collections::HashMap; +use std::iter::Peekable; +use std::ops::BitOr; + +use iterators::Pair; +use RuleType; + +/// Associativity of an [`Operator`]. +/// +/// [`Operator`]: struct.Operator.html +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Assoc { + /// Left `Operator` associativity + Left, + /// Right `Operator` associativity + Right, +} + +/// Infix operator used in [`PrecClimber`]. +/// +/// [`PrecClimber`]: struct.PrecClimber.html +#[derive(Debug)] +pub struct Operator<R: RuleType> { + rule: R, + assoc: Assoc, + next: Option<Box<Operator<R>>>, +} + +impl<R: RuleType> Operator<R> { + /// Creates a new `Operator` from a `Rule` and `Assoc`. + /// + /// # Examples + /// + /// ``` + /// # use pest::prec_climber::{Assoc, Operator}; + /// # #[allow(non_camel_case_types)] + /// # #[allow(dead_code)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// # enum Rule { + /// # plus, + /// # minus + /// # } + /// Operator::new(Rule::plus, Assoc::Left) | Operator::new(Rule::minus, Assoc::Right); + /// ``` + pub fn new(rule: R, assoc: Assoc) -> Operator<R> { + Operator { + rule, + assoc, + next: None, + } + } +} + +impl<R: RuleType> BitOr for Operator<R> { + type Output = Self; + + fn bitor(mut self, rhs: Self) -> Self { + fn assign_next<R: RuleType>(op: &mut Operator<R>, next: Operator<R>) { + if let Some(ref mut child) = op.next { + assign_next(child, next); + } else { + op.next = Some(Box::new(next)); + } + } + + assign_next(&mut self, rhs); + self + } +} + +/// List of operators and precedences, which can perform [precedence climbing][1] on infix +/// expressions contained in a [`Pairs`]. The token pairs contained in the `Pairs` should start +/// with a *primary* pair and then alternate between an *operator* and a *primary*. +/// +/// [1]: https://en.wikipedia.org/wiki/Operator-precedence_parser#Precedence_climbing_method +/// [`Pairs`]: ../iterators/struct.Pairs.html +#[derive(Debug)] +pub struct PrecClimber<R: RuleType> { + ops: HashMap<R, (u32, Assoc)>, +} + +impl<R: RuleType> PrecClimber<R> { + /// Creates a new `PrecClimber` from the `Operator`s contained in `ops`. Every entry in the + /// `Vec` has precedence *index + 1*. In order to have operators with same precedence, they need + /// to be chained with `|` between them. + /// + /// # Examples + /// + /// ``` + /// # use pest::prec_climber::{Assoc, Operator, PrecClimber}; + /// # #[allow(non_camel_case_types)] + /// # #[allow(dead_code)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// # enum Rule { + /// # plus, + /// # minus, + /// # times, + /// # divide, + /// # power + /// # } + /// PrecClimber::new(vec![ + /// Operator::new(Rule::plus, Assoc::Left) | Operator::new(Rule::minus, Assoc::Left), + /// Operator::new(Rule::times, Assoc::Left) | Operator::new(Rule::divide, Assoc::Left), + /// Operator::new(Rule::power, Assoc::Right) + /// ]); + /// ``` + pub fn new(ops: Vec<Operator<R>>) -> PrecClimber<R> { + let ops = ops + .into_iter() + .zip(1..) + .fold(HashMap::new(), |mut map, (op, prec)| { + let mut next = Some(op); + + while let Some(op) = next.take() { + match op { + Operator { + rule, + assoc, + next: op_next, + } => { + map.insert(rule, (prec, assoc)); + next = op_next.map(|op| *op); + } + } + } + + map + }); + + PrecClimber { ops } + } + + /// Performs the precedence climbing algorithm on the `pairs` in a similar manner to map-reduce. + /// *Primary* pairs are mapped with `primary` and then reduced to one single result with + /// `infix`. + /// + /// # Panics + /// + /// Panics will occur when `pairs` is empty or when the alternating *primary*, *operator*, + /// *primary* order is not respected. + /// + /// # Examples + /// + /// ```ignore + /// let primary = |pair| { + /// consume(pair, climber) + /// }; + /// let infix = |lhs: i32, op: Pair<Rule>, rhs: i32| { + /// match op.rule() { + /// Rule::plus => lhs + rhs, + /// Rule::minus => lhs - rhs, + /// Rule::times => lhs * rhs, + /// Rule::divide => lhs / rhs, + /// Rule::power => lhs.pow(rhs as u32), + /// _ => unreachable!() + /// } + /// }; + /// + /// let result = climber.climb(pairs, primary, infix); + /// ``` + pub fn climb<'i, P, F, G, T>(&self, mut pairs: P, mut primary: F, mut infix: G) -> T + where + P: Iterator<Item = Pair<'i, R>>, + F: FnMut(Pair<'i, R>) -> T, + G: FnMut(T, Pair<'i, R>, T) -> T, + { + let lhs = primary( + pairs + .next() + .expect("precedence climbing requires a non-empty Pairs"), + ); + self.climb_rec(lhs, 0, &mut pairs.peekable(), &mut primary, &mut infix) + } + + fn climb_rec<'i, P, F, G, T>( + &self, + mut lhs: T, + min_prec: u32, + pairs: &mut Peekable<P>, + primary: &mut F, + infix: &mut G, + ) -> T + where + P: Iterator<Item = Pair<'i, R>>, + F: FnMut(Pair<'i, R>) -> T, + G: FnMut(T, Pair<'i, R>, T) -> T, + { + while pairs.peek().is_some() { + let rule = pairs.peek().unwrap().as_rule(); + if let Some(&(prec, _)) = self.ops.get(&rule) { + if prec >= min_prec { + let op = pairs.next().unwrap(); + let mut rhs = primary(pairs.next().expect( + "infix operator must be followed by \ + a primary expression", + )); + + while pairs.peek().is_some() { + let rule = pairs.peek().unwrap().as_rule(); + if let Some(&(new_prec, assoc)) = self.ops.get(&rule) { + if new_prec > prec || assoc == Assoc::Right && new_prec == prec { + rhs = self.climb_rec(rhs, new_prec, pairs, primary, infix); + } else { + break; + } + } else { + break; + } + } + + lhs = infix(lhs, op, rhs); + } else { + break; + } + } else { + break; + } + } + + lhs + } +} diff --git a/vendor/pest/src/span.rs b/vendor/pest/src/span.rs new file mode 100644 index 000000000..f8beffe26 --- /dev/null +++ b/vendor/pest/src/span.rs @@ -0,0 +1,301 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::fmt; +use std::hash::{Hash, Hasher}; +use std::ptr; +use std::str; + +use position; + +/// A span over a `&str`. It is created from either [two `Position`s] or from a [`Pair`]. +/// +/// [two `Position`s]: struct.Position.html#method.span +/// [`Pair`]: ../iterators/struct.Pair.html#method.span +#[derive(Clone)] +pub struct Span<'i> { + input: &'i str, + /// # Safety + /// + /// Must be a valid character boundary index into `input`. + start: usize, + /// # Safety + /// + /// Must be a valid character boundary index into `input`. + end: usize, +} + +impl<'i> Span<'i> { + /// Create a new `Span` without checking invariants. (Checked with `debug_assertions`.) + /// + /// # Safety + /// + /// `input[start..end]` must be a valid subslice; that is, said indexing should not panic. + pub(crate) unsafe fn new_unchecked(input: &str, start: usize, end: usize) -> Span { + debug_assert!(input.get(start..end).is_some()); + Span { input, start, end } + } + + /// Attempts to create a new span. Will return `None` if `input[start..end]` is an invalid index + /// into `input`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Span; + /// let input = "Hello!"; + /// assert_eq!(None, Span::new(input, 100, 0)); + /// assert!(Span::new(input, 0, input.len()).is_some()); + /// ``` + #[allow(clippy::new_ret_no_self)] + pub fn new(input: &str, start: usize, end: usize) -> Option<Span> { + if input.get(start..end).is_some() { + Some(Span { input, start, end }) + } else { + None + } + } + + /// Returns the `Span`'s start byte position as a `usize`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let start = Position::from_start(input); + /// let end = start.clone(); + /// let span = start.span(&end); + /// + /// assert_eq!(span.start(), 0); + /// ``` + #[inline] + pub fn start(&self) -> usize { + self.start + } + + /// Returns the `Span`'s end byte position as a `usize`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let start = Position::from_start(input); + /// let end = start.clone(); + /// let span = start.span(&end); + /// + /// assert_eq!(span.end(), 0); + /// ``` + #[inline] + pub fn end(&self) -> usize { + self.end + } + + /// Returns the `Span`'s start `Position`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let start = Position::from_start(input); + /// let end = start.clone(); + /// let span = start.clone().span(&end); + /// + /// assert_eq!(span.start_pos(), start); + /// ``` + #[inline] + pub fn start_pos(&self) -> position::Position<'i> { + // Span's start position is always a UTF-8 border. + unsafe { position::Position::new_unchecked(self.input, self.start) } + } + + /// Returns the `Span`'s end `Position`. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let start = Position::from_start(input); + /// let end = start.clone(); + /// let span = start.span(&end); + /// + /// assert_eq!(span.end_pos(), end); + /// ``` + #[inline] + pub fn end_pos(&self) -> position::Position<'i> { + // Span's end position is always a UTF-8 border. + unsafe { position::Position::new_unchecked(self.input, self.end) } + } + + /// Splits the `Span` into a pair of `Position`s. + /// + /// # Examples + /// + /// ``` + /// # use pest::Position; + /// let input = "ab"; + /// let start = Position::from_start(input); + /// let end = start.clone(); + /// let span = start.clone().span(&end); + /// + /// assert_eq!(span.split(), (start, end)); + /// ``` + #[inline] + pub fn split(self) -> (position::Position<'i>, position::Position<'i>) { + // Span's start and end positions are always a UTF-8 borders. + let pos1 = unsafe { position::Position::new_unchecked(self.input, self.start) }; + let pos2 = unsafe { position::Position::new_unchecked(self.input, self.end) }; + + (pos1, pos2) + } + + /// Captures a slice from the `&str` defined by the `Span`. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "abc"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input).skip(1).unwrap(); + /// let start_pos = state.position().clone(); + /// state = state.match_string("b").unwrap(); + /// let span = start_pos.span(&state.position().clone()); + /// assert_eq!(span.as_str(), "b"); + /// ``` + #[inline] + pub fn as_str(&self) -> &'i str { + // Span's start and end positions are always a UTF-8 borders. + &self.input[self.start..self.end] + } + + /// Iterates over all lines (partially) covered by this span. + /// + /// # Examples + /// + /// ``` + /// # use pest; + /// # #[allow(non_camel_case_types)] + /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + /// enum Rule {} + /// + /// let input = "a\nb\nc"; + /// let mut state: Box<pest::ParserState<Rule>> = pest::ParserState::new(input).skip(2).unwrap(); + /// let start_pos = state.position().clone(); + /// state = state.match_string("b\nc").unwrap(); + /// let span = start_pos.span(&state.position().clone()); + /// assert_eq!(span.lines().collect::<Vec<_>>(), vec!["b\n", "c"]); + /// ``` + #[inline] + pub fn lines(&self) -> Lines { + Lines { + span: self, + pos: self.start, + } + } +} + +impl<'i> fmt::Debug for Span<'i> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Span") + .field("str", &self.as_str()) + .field("start", &self.start) + .field("end", &self.end) + .finish() + } +} + +impl<'i> PartialEq for Span<'i> { + fn eq(&self, other: &Span<'i>) -> bool { + ptr::eq(self.input, other.input) && self.start == other.start && self.end == other.end + } +} + +impl<'i> Eq for Span<'i> {} + +impl<'i> Hash for Span<'i> { + fn hash<H: Hasher>(&self, state: &mut H) { + (self.input as *const str).hash(state); + self.start.hash(state); + self.end.hash(state); + } +} + +/// Line iterator for Spans, created by [`Span::lines()`]. +/// +/// Iterates all lines that are at least partially covered by the span. +/// +/// [`Span::lines()`]: struct.Span.html#method.lines +pub struct Lines<'i> { + span: &'i Span<'i>, + pos: usize, +} + +impl<'i> Iterator for Lines<'i> { + type Item = &'i str; + fn next(&mut self) -> Option<&'i str> { + if self.pos > self.span.end { + return None; + } + let pos = position::Position::new(self.span.input, self.pos)?; + if pos.at_end() { + return None; + } + let line = pos.line_of(); + self.pos = pos.find_line_end(); + Some(line) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn split() { + let input = "a"; + let start = position::Position::from_start(input); + let mut end = start.clone(); + + assert!(end.skip(1)); + + let span = start.clone().span(&end.clone()); + + assert_eq!(span.split(), (start, end)); + } + + #[test] + fn lines_mid() { + let input = "abc\ndef\nghi"; + let span = Span::new(input, 1, 7).unwrap(); + let lines: Vec<_> = span.lines().collect(); + println!("{:?}", lines); + assert_eq!(lines.len(), 2); + assert_eq!(lines[0], "abc\n".to_owned()); + assert_eq!(lines[1], "def\n".to_owned()); + } + + #[test] + fn lines_eof() { + let input = "abc\ndef\nghi"; + let span = Span::new(input, 5, 11).unwrap(); + assert!(span.end_pos().at_end()); + let lines: Vec<_> = span.lines().collect(); + println!("{:?}", lines); + assert_eq!(lines.len(), 2); + assert_eq!(lines[0], "def\n".to_owned()); + assert_eq!(lines[1], "ghi".to_owned()); + } +} diff --git a/vendor/pest/src/stack.rs b/vendor/pest/src/stack.rs new file mode 100644 index 000000000..dede80f1e --- /dev/null +++ b/vendor/pest/src/stack.rs @@ -0,0 +1,219 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::ops::{Index, Range}; + +/// Implementation of a `Stack` which maintains an log of `StackOp`s in order to rewind the stack +/// to a previous state. +#[derive(Debug)] +pub struct Stack<T: Clone> { + ops: Vec<StackOp<T>>, + cache: Vec<T>, + snapshots: Vec<usize>, +} + +impl<T: Clone> Stack<T> { + /// Creates a new `Stack`. + pub fn new() -> Self { + Stack { + ops: vec![], + cache: vec![], + snapshots: vec![], + } + } + + /// Returns `true` if the stack is currently empty. + #[allow(dead_code)] + pub fn is_empty(&self) -> bool { + self.cache.is_empty() + } + + /// Returns the top-most `&T` in the `Stack`. + pub fn peek(&self) -> Option<&T> { + self.cache.last() + } + + /// Pushes a `T` onto the `Stack`. + pub fn push(&mut self, elem: T) { + self.ops.push(StackOp::Push(elem.clone())); + self.cache.push(elem); + } + + /// Pops the top-most `T` from the `Stack`. + pub fn pop(&mut self) -> Option<T> { + let popped = self.cache.pop(); + if let Some(ref val) = popped { + self.ops.push(StackOp::Pop(val.clone())); + } + popped + } + + /// Returns the size of the stack + pub fn len(&self) -> usize { + self.cache.len() + } + + /// Takes a snapshot of the current `Stack`. + pub fn snapshot(&mut self) { + self.snapshots.push(self.ops.len()); + } + + /// The parsing after the last snapshot was successful so clearing it. + pub fn clear_snapshot(&mut self) { + self.snapshots.pop(); + } + + /// Rewinds the `Stack` to the most recent `snapshot()`. If no `snapshot()` has been taken, this + /// function return the stack to its initial state. + pub fn restore(&mut self) { + match self.snapshots.pop() { + Some(ops_index) => { + self.rewind_to(ops_index); + self.ops.truncate(ops_index); + } + None => { + self.cache.clear(); + self.ops.clear(); + } + } + } + + // Rewind the stack to a particular index + fn rewind_to(&mut self, index: usize) { + let ops_to_rewind = &self.ops[index..]; + for op in ops_to_rewind.iter().rev() { + match *op { + StackOp::Push(_) => { + self.cache.pop(); + } + StackOp::Pop(ref elem) => { + self.cache.push(elem.clone()); + } + } + } + } +} + +impl<T: Clone> Index<Range<usize>> for Stack<T> { + type Output = [T]; + + fn index(&self, range: Range<usize>) -> &[T] { + self.cache.index(range) + } +} + +#[derive(Debug)] +enum StackOp<T> { + Push(T), + Pop(T), +} + +#[cfg(test)] +mod test { + use super::Stack; + + #[test] + fn snapshot_with_empty() { + let mut stack = Stack::new(); + + stack.snapshot(); + // [] + assert!(stack.is_empty()); + // [0] + stack.push(0); + stack.restore(); + assert!(stack.is_empty()); + } + + #[test] + fn snapshot_twice() { + let mut stack = Stack::new(); + + stack.push(0); + + stack.snapshot(); + stack.snapshot(); + stack.restore(); + stack.restore(); + + assert_eq!(stack[0..stack.len()], [0]); + } + + #[test] + fn stack_ops() { + let mut stack = Stack::new(); + + // [] + assert!(stack.is_empty()); + assert_eq!(stack.peek(), None); + assert_eq!(stack.pop(), None); + + // [0] + stack.push(0); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&0)); + + // [0, 1] + stack.push(1); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&1)); + + // [0] + assert_eq!(stack.pop(), Some(1)); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&0)); + + // [0, 2] + stack.push(2); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&2)); + + // [0, 2, 3] + stack.push(3); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&3)); + + // Take a snapshot of the current stack + // [0, 2, 3] + stack.snapshot(); + + // [0, 2] + assert_eq!(stack.pop(), Some(3)); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&2)); + + // Take a snapshot of the current stack + // [0, 2] + stack.snapshot(); + + // [0] + assert_eq!(stack.pop(), Some(2)); + assert!(!stack.is_empty()); + assert_eq!(stack.peek(), Some(&0)); + + // [] + assert_eq!(stack.pop(), Some(0)); + assert!(stack.is_empty()); + + // Test backtracking + // [0, 2] + stack.restore(); + assert_eq!(stack.pop(), Some(2)); + assert_eq!(stack.pop(), Some(0)); + assert_eq!(stack.pop(), None); + + // Test backtracking + // [0, 2, 3] + stack.restore(); + assert_eq!(stack.pop(), Some(3)); + assert_eq!(stack.pop(), Some(2)); + assert_eq!(stack.pop(), Some(0)); + assert_eq!(stack.pop(), None); + } +} diff --git a/vendor/pest/src/token.rs b/vendor/pest/src/token.rs new file mode 100644 index 000000000..fbe544ab8 --- /dev/null +++ b/vendor/pest/src/token.rs @@ -0,0 +1,19 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use position::Position; + +/// A token generated by a `Parser`. +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub enum Token<'i, R> { + /// The starting `Position` of a matched `Rule` + Start { rule: R, pos: Position<'i> }, + /// The ending `Position` of a matched `Rule` + End { rule: R, pos: Position<'i> }, +} diff --git a/vendor/pest/src/unicode/binary.rs b/vendor/pest/src/unicode/binary.rs new file mode 100644 index 000000000..8ee9c6f97 --- /dev/null +++ b/vendor/pest/src/unicode/binary.rs @@ -0,0 +1,4933 @@ +// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY: +// +// ucd-generate.exe property-bool --trie-set ./target/ucd/ +// +// ucd-generate is available on crates.io. + +pub const BY_NAME: &'static [(&'static str, &'static ::ucd_trie::TrieSet)] = &[ + ("ASCII_Hex_Digit", ASCII_HEX_DIGIT), ("Alphabetic", ALPHABETIC), + ("Bidi_Control", BIDI_CONTROL), ("Case_Ignorable", CASE_IGNORABLE), + ("Cased", CASED), ("Changes_When_Casefolded", CHANGES_WHEN_CASEFOLDED), + ("Changes_When_Casemapped", CHANGES_WHEN_CASEMAPPED), + ("Changes_When_Lowercased", CHANGES_WHEN_LOWERCASED), + ("Changes_When_Titlecased", CHANGES_WHEN_TITLECASED), + ("Changes_When_Uppercased", CHANGES_WHEN_UPPERCASED), ("Dash", DASH), + ("Default_Ignorable_Code_Point", DEFAULT_IGNORABLE_CODE_POINT), + ("Deprecated", DEPRECATED), ("Diacritic", DIACRITIC), + ("Extender", EXTENDER), ("Grapheme_Base", GRAPHEME_BASE), + ("Grapheme_Extend", GRAPHEME_EXTEND), ("Grapheme_Link", GRAPHEME_LINK), + ("Hex_Digit", HEX_DIGIT), ("Hyphen", HYPHEN), + ("IDS_Binary_Operator", IDS_BINARY_OPERATOR), + ("IDS_Trinary_Operator", IDS_TRINARY_OPERATOR), + ("ID_Continue", ID_CONTINUE), ("ID_Start", ID_START), + ("Ideographic", IDEOGRAPHIC), ("Join_Control", JOIN_CONTROL), + ("Logical_Order_Exception", LOGICAL_ORDER_EXCEPTION), + ("Lowercase", LOWERCASE), ("Math", MATH), + ("Noncharacter_Code_Point", NONCHARACTER_CODE_POINT), + ("Other_Alphabetic", OTHER_ALPHABETIC), + ("Other_Default_Ignorable_Code_Point", OTHER_DEFAULT_IGNORABLE_CODE_POINT), + ("Other_Grapheme_Extend", OTHER_GRAPHEME_EXTEND), + ("Other_ID_Continue", OTHER_ID_CONTINUE), + ("Other_ID_Start", OTHER_ID_START), ("Other_Lowercase", OTHER_LOWERCASE), + ("Other_Math", OTHER_MATH), ("Other_Uppercase", OTHER_UPPERCASE), + ("Pattern_Syntax", PATTERN_SYNTAX), + ("Pattern_White_Space", PATTERN_WHITE_SPACE), + ("Prepended_Concatenation_Mark", PREPENDED_CONCATENATION_MARK), + ("Quotation_Mark", QUOTATION_MARK), ("Radical", RADICAL), + ("Regional_Indicator", REGIONAL_INDICATOR), + ("Sentence_Terminal", SENTENCE_TERMINAL), ("Soft_Dotted", SOFT_DOTTED), + ("Terminal_Punctuation", TERMINAL_PUNCTUATION), + ("Unified_Ideograph", UNIFIED_IDEOGRAPH), ("Uppercase", UPPERCASE), + ("Variation_Selector", VARIATION_SELECTOR), ("White_Space", WHITE_SPACE), + ("XID_Continue", XID_CONTINUE), ("XID_Start", XID_START), +]; + +pub const ASCII_HEX_DIGIT: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x3FF000000000000, 0x7E0000007E, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + ], + tree2_level2: &[ + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const ALPHABETIC: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x420040000000000, 0xFF7FFFFFFF7FFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, 0, 0xBCDF000000000020, + 0xFFFFFFFBFFFFD740, 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFF027FFFFF, 0xBFFF0000000001FF, + 0x787FFFFFF00B6, 0xFFFFFFFF07FF0000, 0xFFFFC000FEFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0x9C00E1FE1FEFFFFF, 0xFFFFFFFFFFFF0000, + 0xFFFFFFFFFFFFE000, 0x3FFFFFFFFFFFF, 0x43007FFFFFFFC00, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 36, 36, + 36, 36, 37, 38, 39, 40, 41, 42, 43, 44, 36, 36, 36, 36, 36, 36, 36, 36, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, + 31, 63, 64, 65, 66, 55, 67, 68, 69, 36, 36, 36, 70, 36, 36, 36, 36, 71, + 72, 73, 74, 31, 75, 76, 31, 77, 78, 79, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 80, 81, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 82, 83, 36, + 84, 85, 86, 87, 88, 89, 31, 31, 31, 31, 31, 31, 31, 90, 44, 91, 92, 93, + 36, 94, 95, 31, 31, 31, 31, 31, 31, 31, 31, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 55, 31, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 96, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 97, 98, 36, 36, 36, 36, 99, + 100, 36, 96, 101, 36, 102, 103, 104, 105, 36, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 36, 117, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 118, 119, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 36, 36, 36, 36, 36, 120, 36, + 121, 122, 123, 124, 125, 36, 36, 36, 36, 126, 127, 128, 129, 31, 130, 36, + 131, 132, 133, 113, 134, + ], + tree2_level2: &[ + 0x1FFFFCFFFFFF, 0x7FF01FFFFFF, 0x3FDFFFFF00000000, 0xFFFF03F8FFF00000, + 0xEFFFFFFFFFFFFFFF, 0xFFFE000FFFE1DFFF, 0xE3C5FDFFFFF99FEF, + 0x1003000FB080599F, 0xC36DFDFFFFF987EE, 0x3F00005E021987, + 0xE3EDFDFFFFFBBFEE, 0x1E00000F00011BBF, 0xE3EDFDFFFFF99FEE, + 0x2000FB0C0199F, 0xC3FFC718D63DC7EC, 0x811DC7, 0xE3FFFDFFFFFDDFEF, + 0xF07601DDF, 0xE3EFFDFFFFFDDFEF, 0x6000F40601DDF, 0xE7FFFFFFFFFDDFEF, + 0xFC00000F80F05DDF, 0x2FFBFFFFFC7FFFEC, 0xC0000FF5F807F, + 0x7FFFFFFFFFFFFFE, 0x207F, 0x3BFFECAEFEF02596, 0xF000205F, 0x1, + 0xFFFE1FFFFFFFFEFF, 0x1FFFFFFFFEFFFF03, 0, 0xF97FFFFFFFFFFFFF, + 0xFFFFC1E7FFFF0000, 0xFFFFFFFF3000407F, 0xF7FFFFFFFFFF20BF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, + 0xFFFFFFFFFF7FFF3D, 0xFFFFFFFFFF3DFFFF, 0x87FFFFFF, 0xFFFFFFFF0000FFFF, + 0x3F3FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, + 0xFFFFFFFF07FFFFFE, 0x1FFC7FFFFFFFFFF, 0xFFFFF000FDFFF, 0xDDFFF000FFFFF, + 0xFFCFFFFFFFFFFFFF, 0x108001FF, 0xFFFFFFFF00000000, 0x1FFFFFFFFFFFFFF, + 0xFFFF07FFFFFFFFFF, 0x3FFFFFFFFFFFFF, 0x1FF0FFF7FFFFFFF, 0x1F3FFFFFFF0000, + 0xFFFF0FFFFFFFFFFF, 0x3FF, 0xFFFFFFFF0FFFFFFF, 0x1FFFFE7FFFFFFF, + 0x8000000000, 0xFFEFFFFFFFFFFFFF, 0xFEF, 0xFC00F3FFFFFFFFFF, + 0x3FFBFFFFFFFFF, 0x3FFFFFFFFC00E000, 0xE7FFFFFFFFFF01FF, 0x6FDE0000000000, + 0x1FFF8000000000, 0xFFFFFFFF3F3FFFFF, 0x3FFFFFFFAAFF3F3F, + 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, 0x8002000000000000, 0x1FFF0000, + 0xF3FFBD503E2FFC84, 0xFFFFFFFF000043E0, 0x1FF, 0xFFC0000000000000, + 0x3FFFFFFFFFF, 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF, 0xC781FFFFFFFFF, + 0xFFFF20BFFFFFFFFF, 0x80FFFFFFFFFF, 0x7F7F7F7F007FFFFF, + 0xFFFFFFFF7F7F7F7F, 0x800000000000, 0x1F3E03FE000000E0, + 0xFFFFFFFEE07FFFFF, 0xF7FFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFE0, + 0x7FFFFFF00007FFF, 0xFFFF000000000000, 0xFFFFFFFFFFFF, 0x1FFF, + 0x3FFFFFFFFFFF0000, 0xC00FFFF1FFF, 0x8FF07FFFFFFFFFFF, 0xFFFFFFFCFF800000, + 0x3FFFFFFFFFFF9FF, 0xFF80000000000000, 0xFFFFFFF7BB, 0xFFFFFFFFFFFFF, + 0x68FC00000000002F, 0xFFFF07FFFFFFFC00, 0x1FFFFFFF0007FFFF, + 0xFFF7FFFFFFFFFFFF, 0x7C00FFDF00008000, 0x7FFFFFFFFFFFFF, + 0xC47FFFFF00003FFF, 0x7FFFFFFFFFFFFFFF, 0x3CFFFF38000005, + 0xFFFF7F7F007E7E7E, 0xFFFF003FF7FFFFFF, 0x7FFFFFFFFFF, 0xFFFF000FFFFFFFFF, + 0xFFFFFFFFFFFF87F, 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, 0x5F7FFDFFE0F8007F, + 0xFFFFFFFFFFFFFFDB, 0x3FFFFFFFFFFFF, 0xFFFFFFFFFFF80000, + 0x3FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, + 0xFFF0000000000FF, 0xFFDF000000000000, 0x1FFFFFFFFFFFFFFF, + 0x7FFFFFE00000000, 0xFFFFFFC007FFFFFE, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 12, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 13, 14, 15, 7, 16, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 5, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 2, 2, 12, 13, 14, 15, 4, + 4, 2, 2, 2, 2, 16, 17, 4, 4, 18, 19, 20, 21, 22, 4, 23, 4, 24, 25, 26, 27, + 28, 29, 30, 4, 2, 31, 32, 32, 33, 4, 4, 4, 4, 4, 4, 4, 34, 35, 4, 4, 2, + 35, 36, 37, 32, 38, 2, 39, 40, 4, 41, 42, 43, 44, 4, 4, 2, 45, 2, 46, 4, + 4, 47, 48, 49, 50, 28, 4, 51, 4, 4, 4, 52, 4, 53, 54, 4, 4, 4, 4, 55, 56, + 57, 52, 4, 4, 4, 4, 58, 59, 60, 4, 61, 62, 63, 4, 4, 4, 4, 64, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 65, 4, 2, 66, 2, 2, 2, 67, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 66, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 68, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 52, 20, 4, 69, 16, 70, 71, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 2, 72, + 73, 74, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 75, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 20, 76, 2, 2, 2, 2, 2, 77, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 2, 78, 79, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 80, 81, 82, 83, 84, 2, 2, + 2, 2, 85, 86, 87, 88, 89, 90, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 91, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 2, 2, 2, 92, 2, 93, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 94, 95, 96, 4, 4, 4, 4, 4, 4, 4, 4, 4, 76, 97, 98, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 99, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 10, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 100, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 101, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 102, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0x1FFFFFFFFFFFFF, 0xFFFFFFFF1FFFFFFF, 0x1FFFF, 0xFFFFE000FFFFFFFF, + 0x7FFFFFFFFFF07FF, 0xFFFFFFFF3FFFFFFF, 0x3EFF0F, 0xFFFF00003FFFFFFF, + 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, 0x7FFFFFFFFFFFFF, + 0xFF003FFFFF, 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, 0x7FFFFFFF, + 0x37FFFF00000000, 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, 0x3FFFFFFEEFF06F, + 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x1FFFFFFEFF, 0x3FFFFFFFFFFFFF, + 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0x7FFFFFFFFFFFF, 0xFFFFFFFFFF, + 0xFFFF00801FFFFFFF, 0x3F, 0x1FFFFFFFFFFFFFC, 0x1FFFFFF0000, + 0x47FFFFFFFF0070, 0x1400001E, 0x409FFFFFFFFBFFFF, 0xFFFF01FFBFFFBD7F, + 0x1FFFFFFFFFF, 0xE3EDFDFFFFF99FEF, 0xFE081199F, 0x7BB, 0xB3, + 0x7F3FFFFFFFFFFFFF, 0x3F000000, 0x7FFFFFFFFFFFFFFF, 0x11, 0x7FFE7FFFFFF, + 0x1FFFFFFFFFFFFFF, 0xFFFFFFFF00000000, 0x80000000FFFFFFFF, + 0x7FE7FFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, 0x20FFFFCF, 0x7F7FFFFFFFFFFDFF, + 0xFFFC000000000001, 0x7FFEFFFFFCFFFF, 0xB47FFFFFFFFFFB7F, + 0xFFFFFDBF000000CB, 0x17B7FFF, 0x7FFFFF00000000, 0x3FFFFFF, + 0x7FFFFFFFFFFF, 0xF, 0x7F, 0x3FFFFFFF0000, 0xE0FFFFF80000000F, 0xFFFF, + 0x7FFFFFFFFFFF001F, 0xFFF80000, 0x300000000, 0x3FFFFFFFFFFFF, + 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, 0x1FFF07FFFFFFFFFF, 0x43FF01FF, + 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, + 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, + 0xF7FFFFFFF7FFFFFD, 0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, + 0xFFFFFDFFFFFFFDFF, 0xFF7, 0x7DBF9FFFF7F, 0x1F, 0x8F, 0xAF7FE96FFFFFFEF, + 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0xFFFF03FFFFFF03FF, 0x3FF, + 0x7FFFFF, 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, 0x3FFFFFFF, + ], +}; + +pub const BIDI_CONTROL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0x10000000, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x7C000000C000, 0x3C000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const CASE_IGNORABLE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x400408000000000, 0x140000000, 0x190A10000000000, 0, 0, 0, 0, 0, 0, 0, + 0xFFFF000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0x430FFFFFFFFFFFF, 0xB0, 0, 0, 0, 0x3F8, 0, 0, 0x2000000, + 0xBFFFFFFFFFFE0000, 0x100000000000B6, 0x17FF003F, 0x10000FFFFF801, 0, + 0x3DFFBFC00000, 0xFFFF000000028000, 0x7FF, 0x1FFC000000000, + 0x243FF80000000000, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 10, 11, 12, 13, 14, 15, 16, 11, 17, 18, + 19, 2, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 33, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 35, 36, 37, + 38, 39, 40, 2, 41, 2, 2, 2, 42, 43, 44, 2, 45, 46, 47, 48, 49, 50, 2, 51, + 52, 53, 54, 55, 2, 2, 2, 2, 2, 2, 56, 57, 58, 59, 60, 61, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 62, 2, 63, 2, 64, 2, 65, 66, + 2, 2, 2, 2, 2, 2, 2, 67, 2, 68, 69, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 70, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 50, 2, 2, 2, 2, 71, 72, 73, 74, 75, 76, 77, 78, 79, 2, 2, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 2, 89, 2, 90, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 91, 2, 92, 93, 2, 2, 2, 2, 2, 2, 2, 2, 94, 95, 2, 96, 97, 98, + 99, 100, + ], + tree2_level2: &[ + 0x3FFFFFC00000, 0xE000000, 0, 0xFFFFFFFFFFF80000, 0x1400000000000007, + 0x2000C00FE21FE, 0x1000000000000002, 0x4000000C0000201E, + 0x1000000000000006, 0x23000000023986, 0xFC00000C000021BE, + 0x9000000000000002, 0xC0040201E, 0x4, 0x2001, 0xC000000000000011, + 0xC00603DC1, 0xC00003040, 0x1800000000000003, 0xC0000201E, 0x5C0400, + 0x7F2000000000000, 0x7FC0, 0x1BF2000000000000, 0x3F40, 0x2A0000003000000, + 0x7FFE000000000000, 0x1FFFFFFFFEFFE0DF, 0x40, 0x66FDE00000000000, + 0x1E0001C3000000, 0x20002064, 0x1000000000000000, 0xE0000000, + 0x1C0000001C0000, 0xC0000000C0000, 0x3FB0000000000000, 0x208FFE40, 0x7800, + 0x8, 0x20000000060, 0xE04018700000000, 0x9800000, 0x9FF81FE57F400000, + 0x7FFF008000000000, 0x17D000000000000F, 0xFF80000000004, 0x3B3C00000003, + 0x3A34000000000, 0xCFF00000000000, 0x3F00000000000000, 0x31021FDFFF70000, + 0xFFFFF00000000000, 0x10007FFFFFFFFFF, 0xFFFFFFFFF8000000, + 0xFBFFFFFFFFFFFFFF, 0xA000000000000000, 0x6000E000E000E003, + 0x7C900300F800, 0x8002FFDF00000000, 0x1FFF0000, 0x1FFFFFFFF0000, + 0x3000000000000000, 0x3800000000000, 0x8000800000000000, + 0xFFFFFFFF00000000, 0x800000000000, 0x83E3C0000000020, 0x7E000000, + 0x7000000000000000, 0x200000, 0x1000, 0xBFF7800000000000, 0xF0000000, + 0x3000000000000, 0x3FFFFFFFF, 0x1000000000000, 0x700, 0x300000000000000, + 0x6000000844, 0x8003FFFF00000030, 0x3FC000000000, 0x3FF80, + 0x13C8000000000007, 0x6000008000, 0x667E0000000000, 0x1001000000001008, + 0xC19D000000000000, 0x58300020000002, 0xF8000000, 0x212000000000, + 0x40000000, 0xFFFC000000000000, 0x3, 0xFFFF0008FFFF, 0x240000, + 0x8000000000000000, 0x4000000004004080, 0x1000000000001, 0xC0000000, + 0xE00000800000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 0, 0, 17, 18, 19, 0, 0, 20, 21, 22, 23, 0, 0, 24, 25, 26, 27, 28, 0, + 29, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 31, 32, 33, 0, 0, 0, 0, 0, 34, 0, + 35, 0, 36, 37, 38, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, + 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 44, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 47, 0, 0, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 54, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 57, 0, 0, 57, 57, 57, 58, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2000000000000000, 0x100000000, 0x7C0000000000000, 0x870000000000F06E, + 0x6000000000, 0xF000000000, 0x1FFC0, 0xFF00000000000002, + 0x800000000000007F, 0x2678000000000003, 0x2000, 0x1FEF8000000007, + 0x8000000000000, 0x7FC0000000000003, 0x1E00, 0x40D3800000000000, + 0x7F880000000, 0x1800000000000003, 0x1F1FC000000001, 0xFF00000000000000, + 0x4000005C, 0x85F8000000000000, 0xD, 0xB03C000000000000, 0x30000001, + 0xA7F8000000000000, 0x1, 0xBF280000000000, 0xFBCE0000000, + 0x6FF800000000000, 0x79F80000000007FE, 0xE7E0080, 0x37FFC00, + 0xBF7F000000000000, 0x6DFCFFFFFC0000, 0xB47E000000000000, 0xBF, 0xA30000, + 0x18000000000000, 0x1F000000000000, 0x7F000000000000, 0xF, 0xFFFF8000, + 0x300000000, 0xF60000000, 0xFFF8038000000000, 0x3C0000000FE7, 0x1C, + 0xF87FFFFFFFFFFFFF, 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F, + 0x7F0000, 0x7F0, 0xF800000000000000, 0xFFFFFFFF00000002, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const CASED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x420040000000000, 0xFF7FFFFFFF7FFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xF7FFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0x1FFFFFFFFEFFFFF, 0x1F00000003, 0, 0xBCCF000000000020, + 0xFFFFFFFBFFFFD740, 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFF007FFFFF, 0x1FF, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 5, 5, 0, 5, 5, 5, 5, 6, 7, 8, 9, 0, 10, 11, + 0, 12, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, + 5, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 0, 23, 5, 24, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 30, 0, + 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0xE7FFFFFFFFFF20BF, 0x3F3FFFFFFFFFFFFF, + 0xE7FFFFFFFFFF01FF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF3F3FFFFF, + 0x3FFFFFFFAAFF3F3F, 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, + 0x8002000000000000, 0x1FFF0000, 0xF21FBD503E2FFC84, 0xFFFFFFFF000043E0, + 0x18, 0xFFC0000000000000, 0x3FFFFFFFFFF, 0xFFFF7FFFFFFFFFFF, + 0xFFFFFFFF7FFFFFFF, 0xC781FFFFFFFFF, 0x20BFFFFFFFFF, 0x3FFFFFFFFFFF, + 0x3FFFFFFF, 0xFFFFFFFC00000000, 0x3FFFFFFFFFF78FF, 0x700000000000000, + 0xFFFF000000000000, 0xFFFF003FF7FFFFFF, 0xF8007F, 0x7FFFFFE00000000, + 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 8, 9, + 10, 11, 12, 1, 1, 1, 1, 13, 14, 15, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 20, 21, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0xFFFF, 0xFFFF000000000000, 0xFFFFFFFFF0FFFFF, + 0x7FFFFFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFFF, 0xFFFFFFFFFFDFFFFF, + 0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, + 0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD, + 0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF, 0xFF7, 0xF, + 0xFFFF03FFFFFF03FF, 0x3FF, + ], +}; + +pub const CHANGES_WHEN_CASEFOLDED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE, 0x20000000000000, 0xFF7FFFFF, 0xAA55555555555555, + 0xAB555555555556AA, 0x11AED2D5B1DBCED6, 0x55D655554AAAADB0, + 0x6C05555555555555, 0x557A, 0, 0, 0, 0x8045000000000020, 0xFFBFFFED740, + 0xE6B3555555638004, 0xFFFFFFFFFFFF, 0x5555555500000000, + 0x5555555555555401, 0x5555555555552AAB, 0xFFFE555555555555, 0x7FFFFF, + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 0, 0, + 0, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, + 5, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 20, 0, 21, 22, 23, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, + 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0x20BF, 0x3F00000000000000, 0xE7FFFFFFFFFF01FF, + 0x5555555555555555, 0x555555554C155555, 0xFF00FF003F00FF00, + 0xFF00AA003F00, 0x1F9CFFFFFFFFFFFF, 0x1F9C1F000F001F9C, 0x40C4000000000, + 0xFFFF00000000, 0x8, 0xFFC0000000000000, 0xFFFF, 0x7FFFFFFFFFFF, + 0xC025EA9D00000000, 0x4280555555555, 0x155555555555, 0x5555555, + 0x5554555400000000, 0x6A00555555555555, 0x15F7D5555452855, + 0xFFFF000000000000, 0xFFFFFFFFFFFFFFFF, 0xF8007F, 0x7FFFFFE00000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFF, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF00000000, 0xFFFFFFFF, 0x3FFFFFFFF, + ], +}; + +pub const CHANGES_WHEN_CASEMAPPED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x20000000000000, 0xFF7FFFFFFF7FFFFF, + 0xFEFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xB3FFF3FFF7FFDFFF, + 0xFFFFFFFFFFFFFFF0, 0xFC0FFFFDFFFFFFFF, 0x20269F6B1ADFFFFF, 0x60041F89, 0, + 0, 0xB8CF000000000020, 0xFFFFFFFBFFFFD740, 0xEFBFFFFFFFE3FFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, + 0xFFFFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFE007FFFFF, 0xFF, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 6, 6, 7, 6, 8, 9, 10, 11, 0, 0, 0, + 0, 12, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, + 6, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 0, 23, 24, 25, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 29, 0, + 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0xE7FFFFFFFFFF20BF, 0x3F3FFFFFFFFFFFFF, + 0xE7FFFFFFFFFF01FF, 0x2200000000000000, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFF4FFFFFFF, 0xFFFFFFFF3F3FFFFF, 0x3FFFFFFFAAFF3F3F, + 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, 0x40C4000000000, + 0xFFFFFFFF00004000, 0x18, 0xFFC0000000000000, 0x3FFFFFFFFFF, + 0xFFFF7FFFFFFFFFFF, 0xC06DFFFF7FFFFFFF, 0xC780FFFFFFFFF, 0x20BFFFFFFFFF, + 0x3FFFFFFFFFFF, 0xFFFFFFF, 0xFFFCFFFC00000000, 0xFE00FFFFFFFFFFFF, + 0x3FF7FFFFFCF38FF, 0xFFFF000000080000, 0xF8007F, 0x7FFFFFE00000000, + 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0xFFFF, 0xFFFF000000000000, 0xFFFFFFFFF0FFFFF, + 0x7FFFFFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFFF, 0xF, + ], +}; + +pub const CHANGES_WHEN_LOWERCASED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE, 0, 0x7F7FFFFF, 0xAA55555555555555, 0x2B555555555554AA, + 0x11AED2D5B1DBCED6, 0x55D655554AAAADB0, 0x6C05555555555555, 0x557A, 0, 0, + 0, 0x8045000000000000, 0xFFBFFFED740, 0xE690555555008000, 0xFFFFFFFFFFFF, + 0x5555555500000000, 0x5555555555555401, 0x5555555555552AAB, + 0xFFFE555555555555, 0x7FFFFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 0, 0, + 0, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, + 5, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 20, 0, 21, 22, 23, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0x20BF, 0x3FFFFFFFFFFFFF, 0xE7FFFFFFFFFF0000, + 0x5555555555555555, 0x5555555540155555, 0xFF00FF003F00FF00, + 0xFF00AA003F00, 0x1F00FF00FF00FF00, 0x1F001F000F001F00, 0x40C4000000000, + 0xFFFF00000000, 0x8, 0xFFC0000000000000, 0xFFFF, 0x7FFFFFFFFFFF, + 0xC025EA9D00000000, 0x4280555555555, 0x155555555555, 0x5555555, + 0x5554555400000000, 0x6A00555555555555, 0x15F7D5555452855, + 0x7FFFFFE00000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFF, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF00000000, 0xFFFFFFFF, 0x3FFFFFFFF, + ], +}; + +pub const CHANGES_WHEN_TITLECASED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE00000000, 0x20000000000000, 0xFF7FFFFF80000000, + 0x54AAAAAAAAAAAAAA, 0xD4AAAAAAAAAAAB55, 0xA251212A46241129, + 0xAA2BAAAAB55556D0, 0x900AAAA8AAAAAAAA, 0x20269F6B1ADFAA85, 0x60041F89, 0, + 0, 0x388A000000000020, 0xFFFFF00000010000, 0x92FAAAAAAE37FFF, + 0xFFFF000000000000, 0xAAAAAAAAFFFFFFFF, 0xAAAAAAAAAAAAA802, + 0xAAAAAAAAAAAAD554, 0xAAAAAAAAAAAA, 0xFFFFFFFE00000000, 0xFF, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 3, 0, 0, 4, 4, 5, 4, 6, 7, 8, 9, 0, 0, 0, 0, + 0, 10, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 15, + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, 0, 19, 20, 21, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, + ], + tree2_level2: &[ + 0, 0x3F00000000000000, 0x1FF, 0x2200000000000000, 0xAAAAAAAAAAAAAAAA, + 0xAAAAAAAA0FEAAAAA, 0xFF00FF003F00FF, 0x3FFF00FF00FF003F, + 0x40DF00FF00FF00FF, 0xDC00FF00CF00DC, 0xFFFF000000004000, 0x10, + 0x3FFFFFF0000, 0xFFFF000000000000, 0x4815627FFFFFFF, 0x8500AAAAAAAAA, + 0x20BFFFFFFFFF, 0x2AAAAAAAAAAA, 0xAAAAAAA, 0xAAA8AAA800000000, + 0x9400AAAAAAAAAAAA, 0x2A002AAAA8A10AA, 0xFFFF000000080000, + 0xFFFFFFFFFFFFFFFF, 0xF8007F, 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFF0000000000, 0xFFFF, 0xFFFFFFFFF000000, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFFC00000000, 0xF, + ], +}; + +pub const CHANGES_WHEN_UPPERCASED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE00000000, 0x20000000000000, 0xFF7FFFFF80000000, + 0x54AAAAAAAAAAAAAA, 0xD4AAAAAAAAAAAB55, 0xA251212A46241129, + 0xAA2DAAAAB5555B60, 0x900AAAA8AAAAAAAA, 0x20269F6B1ADFAA85, 0x60041F89, 0, + 0, 0x388A000000000020, 0xFFFFF00000010000, 0x92FAAAAAAE37FFF, + 0xFFFF000000000000, 0xAAAAAAAAFFFFFFFF, 0xAAAAAAAAAAAAA802, + 0xAAAAAAAAAAAAD554, 0xAAAAAAAAAAAA, 0xFFFFFFFE00000000, 0xFF, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 0, 0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 0, 0, + 0, 0, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15, 5, + 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 19, 0, 20, 21, 22, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, + ], + tree2_level2: &[ + 0, 0xE7FFFFFFFFFF0000, 0x3F00000000000000, 0x1FF, 0x2200000000000000, + 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAA0FEAAAAA, 0xFF00FF003F00FF, + 0x3FFF00FF00FF003F, 0x50DFFFFFFFFFFFFF, 0x10DC00FF00CF10DC, + 0xFFFF000000004000, 0x10, 0x3FFFFFF0000, 0xFFFF000000000000, + 0x4815627FFFFFFF, 0x8500AAAAAAAAA, 0x20BFFFFFFFFF, 0x2AAAAAAAAAAA, + 0xAAAAAAA, 0xAAA8AAA800000000, 0x9400AAAAAAAAAAAA, 0x2A002AAAA8A10AA, + 0xFFFF000000080000, 0xFFFFFFFFFFFFFFFF, 0xF8007F, 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFF0000000000, 0xFFFF, 0xFFFFFFFFF000000, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFFC00000000, 0xF, + ], +}; + +pub const DASH: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x200000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0x4000000000000400, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 1, 0, 0, 0, 0, 0, 0, 8, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 0, 0, 12, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1, 0x40, 0x3F0000, 0x800000000080000, 0x800, 0x40000, + 0xC00000004800000, 0x1000010000000, 0x100000000, 0x6000000000000, + 0x801000000, 0x2000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const DEFAULT_IGNORABLE_CODE_POINT: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x200000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x8000, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0x10000000, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 8, 0, 0, 9, 10, + ], + tree2_level2: &[ + 0, 0x180000000, 0x30000000000000, 0x7800, 0x7C000000F800, 0xFFFF00000000, + 0x1000000000, 0xFFFF, 0x8000000000000000, 0x100000000, 0x1FF000000000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, + ], + tree3_level3: &[ + 0, 0xF00000000, 0x7F8000000000000, 0xFFFFFFFFFFFFFFFF, + ], +}; + +pub const DEPRECATED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0x200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0x8000000000000, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x280000000000000, 0x1800000000, 0xFC0000000000, 0x60000000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2, + ], +}; + +pub const DIACRITIC: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x140000000, 0x190810000000000, 0, 0, 0, 0, 0, 0, 0, + 0xFFFF000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0x4300007E0FF7FFF, 0x30, 0, 0, 0, 0xF8, 0, 0, 0x2000000, + 0xBFFFFFFBFFFE0000, 0x16, 0, 0x187F800, 0, 0x1C6180000000, + 0xFFFF000000000000, 0x7FF, 0x1FFC000000000, 0x3FF80000000000, + ], + tree2_level1: &[ + 0, 1, 1, 2, 3, 4, 3, 5, 3, 5, 3, 6, 3, 5, 1, 5, 1, 5, 3, 5, 7, 5, 1, 8, 1, + 9, 1, 10, 11, 1, 12, 13, 14, 1, 15, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1, 1, 17, 1, 1, 1, + 1, 18, 19, 1, 20, 21, 22, 1, 23, 24, 1, 25, 26, 27, 1, 28, 1, 1, 1, 1, 1, + 1, 29, 30, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 31, 1, 1, 1, 1, 32, 1, 1, 1, 1, 1, 1, 1, 33, 1, 34, 3, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 35, 36, 37, 38, 1, + 39, 40, 1, 1, 1, 41, 42, 43, 44, 45, 1, 46, 47, 48, 1, 49, 1, 50, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 51, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 52, 1, 1, 1, 53, 54, 55, 56, + ], + tree2_level2: &[ + 0x3000000, 0, 0x7FFFFFF800000000, 0x1000000000000000, 0x20000001E2000, + 0x2000, 0xE000000000002000, 0x1800000000000000, 0x400, 0x5F80, 0x1F00, + 0xC2A0000003000000, 0xDC, 0x40, 0x680000000000000, 0xC00BF80, 0x200FFE00, + 0xE00000000000000, 0x9FE0000000000000, 0x3FFF000000000000, + 0x10000000000000, 0xFF80000000010, 0xC0000000000, 0xC0000000000000, + 0x3F00000000000000, 0x39021FFFFFF0000, 0xFFFFF00000000000, 0x7FFFFFFFFFF, + 0xE3E000000000FFF0, 0xA000000000000000, 0x6000E000E000E003, + 0x3800000000000, 0x800000000000, 0xFC0000000000, 0x1E000000, + 0xB000800000000000, 0x30000000, 0x3000000000000, 0x3FF800000, 0x100, + 0x300000000000000, 0x3FFFF00000010, 0x780000000000, 0x80000, + 0x8000000000000, 0x2000000001, 0x3800000000000000, 0x8000000000000000, + 0x40000000000007, 0xF8000000, 0x300000000000, 0x40000000, 0xFFFF00000000, + 0x4000000000000000, 0x1000000000001, 0xC0000000, 0x800000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5, 0, 6, 7, 0, 8, 9, 0, 0, + 10, 11, 12, 0, 0, 0, 13, 0, 14, 0, 0, 15, 16, 15, 0, 17, 0, 18, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 19, 20, 21, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 22, 23, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 26, 27, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x100000000, 0x6000000000, 0xFC00000000, 0x1FFC0, 0x600000000000000, + 0x18000000000000, 0x8000000000000, 0x1C01, 0x60000000000000, + 0x60000000000, 0x1000000000000000, 0x1F1FC000002000, 0x44, 0xC, + 0x8000000000000000, 0x1, 0xC0000000000000, 0x80000000000, + 0x10000000000000, 0x80, 0x2000000, 0x34, 0x800000, 0x1F000000000000, + 0xFFFF8000, 0xF807E38000000000, 0x3C0000000FE7, 0x7F0000, 0x770, + ], +}; + +pub const EXTENDER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x80000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0x30000, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0x1, 0, 0, 0, 0, 0, 0x400000000000000, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, + 0, 13, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, + ], + tree2_level2: &[ + 0, 0x40, 0x400, 0x8, 0x8000000000, 0x40000000000000, 0x800000000000000, + 0x3E000000000020, 0x60000000, 0x7000000000000000, 0x200000, 0x1000, + 0x4000008000, 0x1000000000000, 0x18000020000000, + ], + tree3_level1: &[ + 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x20000000, 0x1C0, 0x1000000, 0xC, 0x300000000, 0x70, + ], +}; + +pub const GRAPHEME_BASE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0xFFFFFFFF00000000, 0x7FFFFFFFFFFFFFFF, 0xFFFFDFFF00000000, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0, + 0xFCFF000000000000, 0xFFFFFFFBFFFFD7F0, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC07, + 0xFFFFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFFFE7FFFFF, + 0x400000000000E7FF, 0x1F87FFFFFF0049, 0xFFFFFFFFC800FFC0, + 0xFFFEFFFF000007FF, 0xFFFFFFFFFFFFFFFF, 0xFFFFC260403FFFFF, + 0xFFFFFFFD3FFF, 0xFFFFFFFFFFFFE000, 0x2003FFFFFFFFF, 0xC7F007FFFFFFFFFF, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 36, 36, + 36, 36, 37, 38, 39, 40, 41, 42, 43, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 44, 45, 46, 47, 48, 49, 50, 45, 51, 52, 53, 54, 55, 56, 57, 58, 59, 3, + 60, 61, 62, 63, 64, 65, 66, 67, 36, 36, 36, 3, 36, 36, 36, 36, 68, 69, 70, + 71, 72, 73, 74, 3, 36, 36, 75, 36, 36, 36, 36, 36, 36, 36, 36, 36, 76, 77, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 78, 79, 80, 81, 82, 36, 83, 84, 85, + 86, 87, 36, 88, 89, 90, 36, 36, 36, 91, 92, 93, 94, 36, 95, 36, 96, 97, + 82, 36, 36, 98, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 52, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 99, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 100, 101, 36, 36, 36, 36, 102, 103, 104, + 105, 36, 36, 106, 107, 108, 109, 36, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 36, 121, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 97, 122, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 36, 36, 36, 36, 36, 123, 36, 124, 125, + 126, 36, 127, 36, 36, 36, 36, 36, 128, 129, 130, 131, 132, 36, 133, 93, + 36, 134, 135, + ], + tree2_level2: &[ + 0x7FFF0110043FFFFF, 0x7FF41FFFFFF, 0x3FDFFFFF00000000, 0, + 0xEBFFFFFFFFFFFFF8, 0xFFFFFFF3FF01DE01, 0xA3C5FDFFFFF99FED, + 0x3FFFFFC3B0005981, 0xC36DFDFFFFF987E8, 0x5CFFC05E000001, + 0xE3EDFDFFFFFBBFE8, 0x203FFC300011A01, 0x23EDFDFFFFF99FEC, + 0xFFFFC3B0001981, 0x83FFC718D63DC7E8, 0x7FFFFC000011DC6, + 0x23FFFDFFFFFDDFEE, 0xFF00FFC30700001E, 0x63EFFDFFFFFDDFFD, + 0x6FFC340000D9B, 0xA7FFFFFFFFFDDFEC, 0xFFFFFFC3FF70DDC1, + 0x2FFBFFFFFC7FFFEC, 0x1CFFC07F03007F, 0x800DFFFFFFFFFFFE, 0xFFF807F, + 0x200DECAEFEF02596, 0xF3FF005F, 0xFD5FFFFFFCFFFFFF, 0x80001FFFFFFFFEFF, + 0xC000000000001F20, 0x7FFDFBF, 0x99021FFFFFFFFFFF, 0xFFE1FFFE3CFFFFFF, + 0xFFFFFFFFDFFFDF9B, 0xFFFFFFFFFFFF20BF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, + 0xFFFFFFFFFF3DFFFF, 0x1FFFFFFF07FFFFFF, 0xFFFFFFFF03FFFFFF, + 0x3F3FFFFFFFFFFFFF, 0xFFFFFFFF1FFFFFFF, 0x1FFFFFFFFFFFFFF, + 0x63FFFF0003DFFF, 0x1DFFF0003FFFF, 0xC04FFFFFFFFFFFFF, 0x3FF03FF1FF001BF, + 0xFFFFFFFF03FF07FF, 0xFFFF05FFFFFFFF9F, 0x3FFFFFFFFFFFFF, + 0x1FB0E787FFFFFFF, 0x1F3FFFFFFFFFF1, 0xFFFF0FFFFFFFFFFF, + 0xFFFFFFFFC7FF03FF, 0xFFFFFFFFC67FFFFF, 0x7E01A00BFFFFF, 0x3FFF03FF03FF, + 0xE82FFFFFFFFFFFF0, 0x1FF007FFFFFF0FFB, 0xFFFFC4C3FFFFFFFC, + 0xF00C5CBFFFFFFFFF, 0xF8300FFFFFFFFFFF, 0xFFFFFFFFFFFFE3FF, + 0xE7FFFFFFFFFF01FF, 0xEFDE02000800FF, 0xFFFFFFFF3F3FFFFF, + 0x3FFFFFFFAAFF3F3F, 0xFFDFFFFFFFFFFFFF, 0x7FDCFFFFEFCFFFDF, + 0xFFFF80FFFFFF07FF, 0xFFF30000FFFFFFFF, 0xFFFFFFFF1FFF7FFF, + 0xFFFFFFFFFFFF0FFF, 0x7FFFFFFFFF, 0xFFFFFFFF000007FF, 0xFFCFFFFFFFFFFFFF, + 0xFFFFFFFFFF3FFFFF, 0x7FFFFFFFFFFFFDFF, 0xFFFF7FFFFFFFFFFF, + 0xFFFFFFFF7FFFFFFF, 0xFE0C7FFFFFFFFFFF, 0xFFFF20BFFFFFFFFF, + 0x180FFFFFFFFFF, 0x7F7F7F7F007FFFFF, 0x7F7F7F7F, 0x7FFF, + 0xFFFFFFFFFBFFFFFF, 0xFFFFFFFFFFFFF, 0xFFF0000003FFFFF, + 0xFFFF03FFFFFFFFFF, 0xFFFFFFFFFFFFFFFE, 0xFFFFFFFFF87FFFFF, + 0xFFFEFFFFFFFFFFE0, 0x7FFFFFFFFFF7FFF, 0xFFFF000FFFFFFFFF, + 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0xFFFFFFFFFFFF1FFF, + 0xFFFFFFFFFFFF007F, 0xFFFFFFFFFFF, 0xC0087FFFFFFFFFFF, 0xFFFFFFFF3FFFFFFF, + 0xFCFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFF, 0xFF80000000000000, + 0x3FF0F9FFFFFF7BB, 0xFFFFFFFFFFFFFF, 0x7FFC000003FFC00F, + 0xFFFFC03FFFFFFFFF, 0x1FFFFFFF800C007F, 0xEC37FFFFFFFFFFF8, + 0x7FFFFFDFC3FFBFFF, 0x1981FFFFFFFFFF, 0xEFFFFFFFF3FF2FF7, + 0x3E62FFFFFFFFFFFF, 0x3FCFFFF8000005, 0xFFFF7F7F007E7E7E, + 0xFFFF003FFFFFFFFF, 0x3FF1EDFFFFFFFFF, 0xFFFFFFFFFFFF87F, + 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, 0x5F7FFFFFA0F8007F, 0xFFFFFFFFFFFFFFDB, + 0xFFFFFFFFFFF80003, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, + 0x3FFF0000000000FF, 0xFFFF000003FF0000, 0xFFDF0F7FFFF7FFFF, + 0x1FFFFFFFFFFFFFFF, 0x7FFFFFFF3FFFFFFF, 0x30007F7F1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 12, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 13, 14, 15, 7, 16, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 2, 5, 6, 7, 7, 8, 9, 10, 11, 12, 13, 2, 2, 14, 15, 16, 17, + 7, 7, 2, 2, 2, 2, 18, 19, 7, 7, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 7, 2, 34, 35, 36, 37, 7, 7, 7, 7, 38, 7, 7, 16, 39, 7, 7, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 7, 49, 50, 51, 52, 7, 7, 53, 54, 55, + 56, 7, 7, 57, 58, 59, 60, 61, 62, 63, 7, 7, 7, 64, 7, 65, 66, 7, 7, 7, 7, + 67, 68, 69, 70, 7, 7, 7, 7, 71, 72, 73, 7, 74, 75, 76, 7, 7, 7, 7, 77, 7, + 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 78, 7, 2, 79, 2, 2, 2, + 80, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 81, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 82, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, + 2, 2, 2, 70, 83, 7, 84, 85, 86, 87, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 88, + 7, 2, 89, 90, 91, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 92, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 35, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 93, 94, 2, 2, 2, 2, 2, 95, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 96, 97, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 2, 2, 2, 98, 99, 100, 101, 102, 2, 103, 7, 104, 2, 105, 7, 7, 2, 106, + 107, 108, 109, 110, 2, 2, 2, 2, 111, 2, 2, 2, 2, 112, 2, 2, 2, 2, 2, 2, 2, + 2, 113, 114, 115, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 116, 2, 117, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 118, 119, 7, 7, 7, 7, 7, 120, 121, 122, 123, 7, 7, 7, 7, 124, 2, + 125, 126, 127, 124, 128, 129, 130, 131, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 132, 2, 133, 2, 134, 135, 136, 137, 7, 138, 139, 140, + 141, 7, 142, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 143, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 119, 2, 2, 2, + 144, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 145, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 146, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, + 2, 2, 2, 147, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, + 0xFF8FFFFFFFFFFF87, 0x10FFF7FFF, 0x1FFFFFFFFFFF0000, 0, + 0xFFFFFFFF1FFFFFFF, 0xFFFFFFE0001FFFF, 0xFFFFE00FFFFFFFFF, + 0x3FFFFFFFFF07FF, 0xFFFFFFFFBFFFFFFF, 0x3FFF0F, 0xFFFF03FF3FFFFFFF, + 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF, 0x800FFFFFFFFF, 0x7FFFFFFFFFFFFF, + 0xFF003FFFFF, 0x91BFFFFFFFFFFD3F, 0xFFFFFFFFFFBFFFFF, 0xFF807FFFFFFF, + 0xF837FFFF00000000, 0x83FFFFFF8FFFFFFF, 0xF0FFFFFFFFFFFFFF, + 0xFFFFFFFFFFFCFFFF, 0x3FFFFFFEEF0001, 0xFFFFFFFF01FF01FF, 0xFFFFFFFF, + 0x7FF81FFFFFFFFF, 0xFE3FFFFFFFFFFFFF, 0xFF07FFFFFF3FFFFF, 0xFE001E03FFFF, + 0x1FF, 0x7FFFFFFFFFFFF, 0xFC07FFFFFFFFFFFF, 0x3FF000FFFFFFFFF, + 0x7FFFFFFF00000000, 0x3FE003F, 0xFFFFFFFFFFFFFD, 0xFFFFFFFC3F80, + 0xD987FFFFFFFFFFFC, 0x3FF01FFFFFF0003, 0xFFC0107FFFFFFFF8, + 0x77FFFFFFFF007F, 0x803FFFFFFFFFFFFC, 0x1FFFFEFFFF21FF, + 0x3F2C7FFFFFFBFFFF, 0xFFFF03FFBFFFBD7F, 0x3FF00077FFFFFFF, + 0xA3EDFDFFFFF99FEC, 0xFE001399E, 0xFFFFFFFFFFFFFF, 0x2BFFFFA3, + 0x5A06FFFFFFFFFFFF, 0x3FF00F2, 0x4F037FFFFFFFFFFF, 0xFFFFFFE, + 0x5807FFFFFFFFFFFF, 0x1FFF03FF001E, 0x40D7FFFFFFFFFF, 0x3FF, + 0xFFFF004307FFFFFF, 0x9007FFFFFFFFFFF, 0xFFFFFFFF00000000, + 0x8007FFFFFFFFFFFF, 0x8607FFFFFFFFF801, 0xFFFFFFFFF181007F, 0x7FC8003CF, + 0x1FFFFFFFFFFFFFF, 0x4000FFFFFFFFFDFF, 0xFFFF1FFFFFFF003F, + 0x1202000000FFFF, 0x1FFFFFFFFFB7F, 0xFFFFFDBF03FF0040, 0x3FF01587FFF, + 0x1E7FFFF00000000, 0x3FFFFFF, 0x1F7FFFFFFFFFFF, 0xF, 0x7FFFFFFFFFFF, 0x7F, + 0xC3FF7FFFFFFF, 0x203FFFFFFF0000, 0xFF80FFFFFFFFFFFF, 0xE0FFFFFBFBFF003F, + 0xFFFF, 0x7FFFFFF, 0x7FFFFFFFFFFF001F, 0xFFF80000, 0x300000000, + 0x3FFFFFFFFFFFF, 0x7FFFFFFF, 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, + 0x1FFF07FFFFFFFFFF, 0x93FF01FF, 0x3FFFFFFFFFFFFF, 0xFFFFFE7FFFFFFFFF, + 0x3C5FFFFFFFFF, 0xFFFFC3FFFFFFF018, 0x1FFFFFFFFFF, 0x23, 0xFFFFF00000000, + 0x1FFFFFF007FFFFF, 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, + 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, + 0xFFFFFF3FFFFFFFFF, 0xFFFFFFFFFFFFCFFF, 0x780000000000000, + 0xFFDFE00000000000, 0xFEF, 0xFF9F, 0xC3FF000F, 0xFFFE000000000000, + 0x1FFFFFFFFFFFFF, 0xAF7FE96FFFFFFEF, 0x5EF7F796AA96EA84, + 0xFFFFBEE0FFFFBFF, 0x3000000000000, 0xFFFF0FFFFFFFFFFF, + 0xFFFE7FFF000FFFFF, 0x3FFFFFFFFEFFFE, 0xFFFFFFFFFFFF1FFF, 0x1FFFFFFFFFFF, + 0xFFFFFFC000000000, 0xFFFFFFFFFFF0007, 0x3F000301FF, 0x3FF1FFF001FFFFF, + 0xFFFFFFFFFFFFF, 0x1FFFFFF, 0xFFFFFFFFFFFF0FFF, 0xFFFFFFFF03FF00FF, + 0x3FFFFFFF00FF, 0x7FFFFFFFFFFF0FFF, 0xF479FFFFFFFFFFFF, 0x3FF0007FFFFFFFF, + 0xFFFFFFFFFFFF0007, 0x3FFF00000000, 0x7FFFFF, 0xFFFFFFFF3FFFFFFF, + 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, 0x3FFFFFFF, + ], +}; + +pub const GRAPHEME_EXTEND: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0, + 0, 0, 0, 0x3F8, 0, 0, 0, 0xBFFFFFFFFFFE0000, 0xB6, 0x7FF0000, + 0x10000FFFFF800, 0, 0x3D9F9FC00000, 0xFFFF000000020000, 0x7FF, + 0x1FFC000000000, 0x200FF80000000000, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 2, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 33, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 35, 36, 37, + 38, 2, 39, 2, 40, 2, 2, 2, 41, 42, 43, 2, 44, 45, 46, 47, 48, 2, 2, 49, 2, + 2, 2, 50, 2, 2, 2, 2, 2, 2, 2, 2, 51, 2, 2, 52, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 53, 2, 54, 2, 55, 2, 2, 2, 2, 2, 2, + 2, 2, 56, 2, 57, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 58, 59, 60, 2, 2, 2, 2, 61, 2, 2, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 2, 2, 2, 71, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 72, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 73, 2, 2, 2, 2, 2, 59, 2, + ], + tree2_level2: &[ + 0x3EEFFBC00000, 0xE000000, 0, 0xFFFFFFFBFFF80000, 0x1400000000000007, + 0xC00FE21FE, 0x5000000000000002, 0x4000000C0080201E, 0x1000000000000006, + 0x23000000023986, 0xFC00000C000021BE, 0xD000000000000002, 0xC00C0201E, + 0x4000000000000004, 0x802001, 0xC000000000000011, 0xC00603DC1, + 0x9000000000000002, 0xC00603044, 0x5800000000000003, 0xC0080201E, + 0x805C8400, 0x7F2000000000000, 0x7F80, 0x1BF2000000000000, 0x3F00, + 0x2A0000003000000, 0x7FFE000000000000, 0x1FFFFFFFFEFFE0DF, 0x40, + 0x66FDE00000000000, 0x1E0001C3000000, 0x20002064, 0xE0000000, + 0x1C0000001C0000, 0xC0000000C0000, 0x3FB0000000000000, 0x200FFE40, 0x3800, + 0x20000000060, 0xE04018700000000, 0x9800000, 0x9FF81FE57F400000, + 0x7FFF000000000000, 0x17D000000000000F, 0xFF80000000004, 0x3B3C00000003, + 0x3A34000000000, 0xCFF00000000000, 0x31021FDFFF70000, 0xFBFFFFFFFFFFFFFF, + 0x1000, 0x1FFFFFFFF0000, 0x3800000000000, 0x8000000000000000, + 0xFFFFFFFF00000000, 0xFC0000000000, 0x6000000, 0x3FF7800000000000, + 0xC0000000, 0x3000000000000, 0x6000000844, 0x8003FFFF00000030, + 0x3FC000000000, 0x3FF80, 0x13C8000000000007, 0x2000000000, + 0x667E0000000000, 0x1000000000001008, 0xC19D000000000000, + 0x40300000000002, 0x212000000000, 0x40000000, 0xFFFF0000FFFF, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 8, 9, 10, 0, 11, 12, 13, 14, 15, + 0, 0, 16, 17, 18, 0, 0, 19, 20, 21, 22, 0, 0, 23, 24, 25, 26, 27, 0, 28, + 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 0, 0, 0, 0, 0, 33, 0, 34, 0, + 35, 36, 37, 0, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 40, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 44, 0, 0, 45, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 46, 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 53, 0, 0, 53, 53, 53, + 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2000000000000000, 0x100000000, 0x7C0000000000000, 0x870000000000F06E, + 0x6000000000, 0xF000000000, 0x1FFC0, 0xFF00000000000002, + 0x800000000000007F, 0x678000000000003, 0x1FEF8000000007, 0x8000000000000, + 0x7FC0000000000003, 0x1E00, 0x40D3800000000000, 0x7F880000000, + 0x5800000000000003, 0x1F1FC000800001, 0xFF00000000000000, 0x4000005C, + 0xA5F9000000000000, 0xD, 0xB03C800000000000, 0x30000001, + 0xA7F8000000000000, 0x1, 0xBF280000000000, 0xFBCE0000000, + 0x6FF800000000000, 0x79F80000000007FE, 0xE7E0080, 0x37FFC00, + 0xBF7F000000000000, 0x6DFCFFFFFC0000, 0xB47E000000000000, 0xBF, 0xA30000, + 0x18000000000000, 0x1F000000000000, 0x7F000000000000, 0x78000, 0x60000000, + 0xF807C3A000000000, 0x3C0000000FE7, 0x1C, 0xF87FFFFFFFFFFFFF, + 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F, 0x7F0000, 0x7F0, + 0xFFFFFFFF00000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const GRAPHEME_LINK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 0, 3, 4, + 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, + 0, 0, 5, 10, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 5, 0, 14, 0, + 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x2000, 0x1800000000000000, 0x400, 0x400000000000000, 0x10, + 0x600000000000000, 0x10000000100000, 0x40000, 0x100000000, 0xC0000000000, + 0xC000000000000, 0x8000000000000000, 0x40, 0x80000, 0x1, 0x40000000000000, + 0x200000000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 4, 0, 0, 5, 6, 0, 0, + 7, 0, 8, 0, 0, 0, 9, 0, 9, 0, 0, 1, 0, 1, 0, 10, 0, 11, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 12, 13, 14, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 15, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x8000000000000000, 0x8000000000000040, 0x200000000000000, + 0x18000000000000, 0x1, 0x20000000000000, 0x40000000000, 0x2000, 0x4, + 0x40000000000000, 0x80000000000, 0x10000000000000, 0x80, 0x2000000, 0x30, + 0x800000, + ], +}; + +pub const HEX_DIGIT: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x3FF000000000000, 0x7E0000007E, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, + ], + tree2_level2: &[ + 0, 0x7E03FF0000, 0x7E, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const HYPHEN: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x200000000000, 0, 0x200000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0x400, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 6, 7, 0, 0, + ], + tree2_level2: &[ + 0, 0x40, 0x30000, 0x800000, 0x800000000000000, 0x800000000, 0x2000, + 0x2000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const IDS_BINARY_OPERATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFF3000000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const IDS_TRINARY_OPERATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xC000000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const ID_CONTINUE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x3FF000000000000, 0x7FFFFFE87FFFFFE, 0x4A0040000000000, + 0xFF7FFFFFFF7FFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, + 0xFFFFFFFFFFFFFFFF, 0xBCDFFFFFFFFFFFFF, 0xFFFFFFFBFFFFD7C0, + 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFCFB, 0xFFFFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFFF, + 0xFFFFFFFF027FFFFF, 0xBFFFFFFFFFFE01FF, 0x787FFFFFF00B6, + 0xFFFFFFFF07FF0000, 0xFFFFC3FFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0x9FFFFDFF9FEFFFFF, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFFE7FF, + 0x3FFFFFFFFFFFF, 0x243FFFFFFFFFFFFF, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 4, 32, 33, 34, 4, 4, 4, 4, 4, + 35, 36, 37, 38, 39, 40, 41, 42, 4, 4, 4, 4, 4, 4, 4, 4, 43, 44, 45, 46, + 47, 4, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 4, 61, 4, 62, + 63, 64, 65, 66, 4, 4, 4, 67, 4, 4, 4, 4, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 79, 80, 4, 81, 82, 83, 84, 85, 60, 60, 60, + 60, 60, 60, 60, 60, 86, 42, 87, 88, 89, 4, 90, 91, 60, 60, 60, 60, 60, 60, + 60, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 52, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 92, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 93, 94, 4, 4, 4, 4, 95, 96, 4, 97, 98, 4, 99, 100, 101, 62, + 4, 102, 103, 104, 4, 105, 106, 107, 4, 108, 109, 110, 4, 111, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 112, 113, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 4, 4, 4, 4, 4, 103, 4, 114, 115, 116, 97, 117, 4, 4, + 4, 4, 118, 119, 120, 121, 122, 123, 4, 124, 125, 126, 127, 128, + ], + tree2_level2: &[ + 0x3FFFFFFFFFFF, 0x7FF0FFFFFFF, 0x3FDFFFFF00000000, 0xFFFFFFFBFFF80000, + 0xFFFFFFFFFFFFFFFF, 0xFFFEFFCFFFFFFFFF, 0xF3C5FDFFFFF99FEF, + 0x5003FFCFB080799F, 0xD36DFDFFFFF987EE, 0x3FFFC05E023987, + 0xF3EDFDFFFFFBBFEE, 0xFE00FFCF00013BBF, 0xF3EDFDFFFFF99FEE, + 0x2FFCFB0C0399F, 0xC3FFC718D63DC7EC, 0xFFC000813DC7, 0xE3FFFDFFFFFDDFFF, + 0xFFCF07603DDF, 0xF3EFFDFFFFFDDFEF, 0x6FFCF40603DDF, 0xFFFFFFFFFFFDDFEF, + 0xFC00FFCF80F07DDF, 0x2FFBFFFFFC7FFFEC, 0xCFFC0FF5F847F, + 0x7FFFFFFFFFFFFFE, 0x3FF7FFF, 0x3BFFECAEFEF02596, 0xF3FF3F5F, + 0xC2A003FF03000001, 0xFFFE1FFFFFFFFEFF, 0x1FFFFFFFFEFFFFDF, 0x40, + 0xFFFFFFFFFFFF03FF, 0xFFFFFFFF3FFFFFFF, 0xF7FFFFFFFFFF20BF, + 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, + 0xFFFFFFFFFF3DFFFF, 0x3FE00E7FFFFFF, 0xFFFFFFFF0000FFFF, + 0x3F3FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, + 0xFFFFFFFF07FFFFFE, 0x1FFC7FFFFFFFFFF, 0x1FFFFF001FDFFF, 0xDDFFF000FFFFF, + 0x3FF308FFFFF, 0xFFFFFFFF03FF3800, 0x1FFFFFFFFFFFFFF, 0xFFFF07FFFFFFFFFF, + 0x3FFFFFFFFFFFFF, 0xFFF0FFF7FFFFFFF, 0x1F3FFFFFFFFFC0, 0xFFFF0FFFFFFFFFFF, + 0x7FF03FF, 0xFFFFFFFF0FFFFFFF, 0x9FFFFFFF7FFFFFFF, 0x3FFF008003FF03FF, 0, + 0xFF80003FF0FFF, 0xFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFE3FF, + 0xE7FFFFFFFFFF01FF, 0x3FFFFFFFFF70000, 0xFBFFFFFFFFFFFFFF, + 0xFFFFFFFF3F3FFFFF, 0x3FFFFFFFAAFF3F3F, 0x5FDFFFFFFFFFFFFF, + 0x1FDC1FFF0FCF1FDC, 0x8000000000000000, 0x8002000000100001, 0x1FFF0000, + 0x1FFE21FFF0000, 0xF3FFFD503F2FFC84, 0xFFFFFFFF000043E0, 0x1FF, + 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF, 0xFF81FFFFFFFFF, + 0xFFFF20BFFFFFFFFF, 0x800080FFFFFFFFFF, 0x7F7F7F7F007FFFFF, + 0xFFFFFFFF7F7F7F7F, 0x1F3EFFFE000000E0, 0xFFFFFFFEFE7FFFFF, + 0xF7FFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFE0, 0x7FFFFFF00007FFF, + 0xFFFF000000000000, 0xFFFFFFFFFFFF, 0x1FFF, 0x3FFFFFFFFFFF0000, + 0xFFFFFFF1FFF, 0xBFF0FFFFFFFFFFFF, 0x3FFFFFFFFFFFF, 0xFFFFFFFCFF800000, + 0x3FFFFFFFFFFF9FF, 0xFF80000000000000, 0xFFFFFFFFFF, 0xE8FFFFFF03FF003F, + 0xFFFF3FFFFFFFFFFF, 0x1FFFFFFF000FFFFF, 0x7FFFFFFF03FF8001, + 0x7FFFFFFFFFFFFF, 0xFC7FFFFF03FF3FFF, 0x7CFFFF38000007, + 0xFFFF7F7F007E7E7E, 0xFFFF003FF7FFFFFF, 0x3FF37FFFFFFFFFF, + 0xFFFF000FFFFFFFFF, 0xFFFFFFFFFFFF87F, 0x3FFFFFF, 0x5F7FFDFFE0F8007F, + 0xFFFFFFFFFFFFFFDB, 0xFFFFFFFFFFF80000, 0x3FFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, 0xFFF0000000000FF, + 0x18FFFF0000FFFF, 0xFFDF00000000E000, 0x1FFFFFFFFFFFFFFF, + 0x87FFFFFE03FF0000, 0xFFFFFFC007FFFFFE, 0x7FFFFFFFFFFFFFFF, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 12, 13, 14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 5, 4, 6, 4, 4, 7, 8, 9, 10, 11, 12, 2, 2, 13, 14, 15, 16, + 4, 4, 2, 2, 2, 2, 17, 18, 4, 4, 19, 20, 21, 22, 23, 4, 24, 4, 25, 26, 27, + 28, 29, 30, 31, 4, 2, 32, 33, 33, 34, 4, 4, 4, 4, 4, 4, 4, 35, 36, 4, 4, + 2, 37, 3, 38, 39, 40, 2, 41, 42, 4, 43, 44, 45, 46, 4, 4, 2, 47, 2, 48, 4, + 4, 49, 50, 2, 51, 52, 53, 54, 4, 4, 4, 3, 4, 55, 56, 4, 4, 4, 4, 57, 58, + 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 2, 69, 2, 2, 2, 70, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 69, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 71, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 60, 72, 4, 73, 17, 74, 75, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 2, 76, + 77, 78, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 79, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 21, 80, 2, 2, 2, 2, 2, 81, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 2, 82, 83, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 84, 85, 4, 4, 86, 4, 4, 4, 4, 4, 4, 2, 87, 88, 89, 90, 91, 2, + 2, 2, 2, 92, 93, 94, 95, 96, 97, 4, 4, 4, 4, 4, 4, 4, 4, 98, 99, 100, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 101, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 2, 2, 2, 102, 2, 103, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 104, 105, 106, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 107, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 11, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 108, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 109, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 110, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 111, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0x1FFFFFFFFFFFFF, 0x2000000000000000, 0xFFFFFFFF1FFFFFFF, 0x10001FFFF, + 0xFFFFE000FFFFFFFF, 0x7FFFFFFFFFF07FF, 0xFFFFFFFF3FFFFFFF, 0x3EFF0F, + 0xFFFF03FF3FFFFFFF, 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, + 0x7FFFFFFFFFFFFF, 0xFF003FFFFF, 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, + 0x7FFFFFFF, 0x37FFFF00000000, 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, + 0x873FFFFFFEEFF06F, 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x7FFFFFFEFF, + 0x3FFFFFFFFFFFFF, 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0x7FFFFFFFFFFFF, + 0x3FF00FFFFFFFFFF, 0xFFFF00801FFFFFFF, 0x1FFFF, 0x8000FFC00000007F, + 0x3FF01FFFFFF0000, 0xFFDFFFFFFFFFFFFF, 0x4FFFFFFFFF0070, 0x17FF1E1F, + 0x40FFFFFFFFFBFFFF, 0xFFFF01FFBFFFBD7F, 0x3FF07FFFFFFFFFF, + 0xFBEDFDFFFFF99FEF, 0x1F1FCFE081399F, 0x43FF07FF, 0x3FF00BF, + 0xFF3FFFFFFFFFFFFF, 0x3F000001, 0x3FF0011, 0xFFFFFFFFFFFFFF, 0x3FF, + 0x3FF0FFFE7FFFFFF, 0xFFFFFFFF00000000, 0x800003FFFFFFFFFF, + 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0080, 0x23FFFFCF, 0x1FFFFFFFFFFFFFF, + 0xFF7FFFFFFFFFFDFF, 0xFFFC000003FF0001, 0x7FFEFFFFFCFFFF, + 0xB47FFFFFFFFFFB7F, 0xFFFFFDBF03FF00FF, 0x3FF01FB7FFF, 0x7FFFFF00000000, + 0x3FFFFFF, 0x7FFFFFFFFFFF, 0xF, 0x7F, 0x3FF7FFFFFFF, 0x1F3FFFFFFF0000, + 0xE0FFFFF803FF000F, 0xFFFF, 0x7FFFFFFFFFFF001F, 0xFFFF8000, 0x300000000, + 0x3FFFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, + 0x1FFF07FFFFFFFFFF, 0x63FF01FF, 0xF807E3E000000000, 0x3C0000000FE7, 0x1C, + 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, + 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, + 0xF7FFFFFFF7FFFFFD, 0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, + 0xFFFFFDFFFFFFFDFF, 0xFFFFFFFFFFFFCFF7, 0xF87FFFFFFFFFFFFF, + 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F, 0x7F001F, 0x3FF07FF, + 0xAF7FE96FFFFFFEF, 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x7FFFFF, + 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, 0x3FFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const ID_START: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x420040000000000, 0xFF7FFFFFFF7FFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, 0, 0xBCDF000000000000, + 0xFFFFFFFBFFFFD740, 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFF027FFFFF, 0x1FF, 0x787FFFFFF0000, + 0xFFFFFFFF00000000, 0xFFFEC000000007FF, 0xFFFFFFFFFFFFFFFF, + 0x9C00C060002FFFFF, 0xFFFFFFFD0000, 0xFFFFFFFFFFFFE000, 0x2003FFFFFFFFF, + 0x43007FFFFFFFC00, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 23, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 34, 34, 34, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 34, 34, 34, 34, 34, 34, 34, 34, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 3, 61, + 62, 63, 64, 65, 66, 67, 68, 34, 34, 34, 3, 34, 34, 34, 34, 69, 70, 71, 72, + 3, 73, 74, 3, 75, 76, 77, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 78, 79, 34, 80, 81, 82, 83, 84, 3, 3, 3, 3, 3, 3, 3, 3, 85, 42, 86, 87, + 88, 34, 89, 90, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 53, 3, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 91, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 92, 93, 34, 34, 34, 34, 94, 95, 96, + 91, 97, 34, 98, 99, 100, 48, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 34, 113, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 114, 115, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 116, 34, 117, 118, + 119, 120, 121, 34, 34, 34, 34, 122, 123, 124, 125, 3, 126, 34, 127, 128, + 129, 130, 131, + ], + tree2_level2: &[ + 0x110043FFFFF, 0x7FF01FFFFFF, 0x3FDFFFFF00000000, 0, 0x23FFFFFFFFFFFFF0, + 0xFFFE0003FF010000, 0x23C5FDFFFFF99FE1, 0x10030003B0004000, + 0x36DFDFFFFF987E0, 0x1C00005E000000, 0x23EDFDFFFFFBBFE0, + 0x200000300010000, 0x23EDFDFFFFF99FE0, 0x20003B0000000, 0x3FFC718D63DC7E8, + 0x10000, 0x23FFFDFFFFFDDFE0, 0x307000000, 0x23EFFDFFFFFDDFE1, + 0x6000340000000, 0x27FFFFFFFFFDDFE0, 0xFC00000380704000, + 0x2FFBFFFFFC7FFFE0, 0x7F, 0xDFFFFFFFFFFFE, 0x200DECAEFEF02596, 0xF000005F, + 0x1, 0x1FFFFFFFFEFF, 0x1F00, 0x800007FFFFFFFFFF, 0xFFE1C0623C3F0000, + 0xFFFFFFFF00004003, 0xF7FFFFFFFFFF20BF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, + 0xFFFFFFFFFF3DFFFF, 0x7FFFFFF, 0xFFFFFFFF0000FFFF, 0x3F3FFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, 0xFFFFFFFF07FFFFFE, + 0x1FFC7FFFFFFFFFF, 0x3FFFF0003DFFF, 0x1DFFF0003FFFF, 0xFFFFFFFFFFFFF, + 0x10800000, 0xFFFFFFFF00000000, 0x1FFFFFFFFFFFFFF, 0xFFFF05FFFFFFFFFF, + 0x3FFFFFFFFFFFFF, 0x7FFFFFFF, 0x1F3FFFFFFF0000, 0xFFFF0FFFFFFFFFFF, 0x3FF, + 0xFFFFFFFF007FFFFF, 0x1FFFFF, 0x8000000000, 0xFFFFFFFFFFFE0, 0xFE0, + 0xFC00C001FFFFFFF8, 0x3FFFFFFFFF, 0xFFFFFFFFF, 0x3FFFFFFFFC00E000, + 0xE7FFFFFFFFFF01FF, 0x63DE0000000000, 0xFFFFFFFF3F3FFFFF, + 0x3FFFFFFFAAFF3F3F, 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, + 0x8002000000000000, 0x1FFF0000, 0xF3FFFD503F2FFC84, 0xFFFFFFFF000043E0, + 0x1FF, 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF, 0xC781FFFFFFFFF, + 0xFFFF20BFFFFFFFFF, 0x80FFFFFFFFFF, 0x7F7F7F7F007FFFFF, 0x7F7F7F7F, + 0x1F3E03FE000000E0, 0xFFFFFFFEF87FFFFF, 0xF7FFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFE0, 0x7FFFFFF00007FFF, 0xFFFF000000000000, 0xFFFFFFFFFFFF, + 0x1FFF, 0x3FFFFFFFFFFF0000, 0xC00FFFF1FFF, 0x80007FFFFFFFFFFF, + 0xFFFFFFFF3FFFFFFF, 0xFFFFFFFCFF800000, 0x3FFFFFFFFFFF9FF, + 0xFF80000000000000, 0x7FFFFF7BB, 0xFFFFFFFFFFFFC, 0x68FC000000000000, + 0xFFFF003FFFFFFC00, 0x1FFFFFFF0000007F, 0x7FFFFFFFFFFF0, + 0x7C00FFDF00008000, 0x1FFFFFFFFFF, 0xC47FFFFF00000FF7, 0x3E62FFFFFFFFFFFF, + 0x1C07FF38000005, 0xFFFF7F7F007E7E7E, 0xFFFF003FF7FFFFFF, 0x7FFFFFFFF, + 0xFFFF000FFFFFFFFF, 0xFFFFFFFFFFFF87F, 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, + 0x5F7FFDFFA0F8007F, 0xFFFFFFFFFFFFFFDB, 0x3FFFFFFFFFFFF, + 0xFFFFFFFFFFF80000, 0x3FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, + 0xFFFFFFFFFFFCFFFF, 0xFFF0000000000FF, 0xFFDF000000000000, + 0x1FFFFFFFFFFFFFFF, 0x7FFFFFE00000000, 0xFFFFFFC007FFFFFE, + 0x7FFFFFFFFFFFFFFF, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 12, 13, 14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 5, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 2, 2, 12, 13, 14, 15, 4, + 4, 2, 2, 2, 2, 16, 17, 4, 4, 18, 19, 20, 21, 22, 4, 23, 4, 24, 25, 26, 27, + 28, 29, 30, 4, 2, 31, 32, 32, 15, 4, 4, 4, 4, 4, 4, 4, 33, 34, 4, 4, 35, + 4, 36, 37, 38, 39, 40, 41, 42, 4, 43, 20, 44, 45, 4, 4, 5, 46, 47, 48, 4, + 4, 49, 50, 47, 51, 52, 4, 53, 4, 4, 4, 54, 4, 55, 56, 4, 4, 4, 4, 57, 58, + 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 2, 49, 2, 2, 2, 69, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 49, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 70, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 60, 20, 4, 71, 47, 72, 63, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 2, 73, + 74, 75, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 76, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 20, 77, 2, 2, 2, 2, 2, 78, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 2, 79, 80, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 81, 82, 83, 84, 85, 2, 2, + 2, 2, 86, 87, 88, 89, 90, 91, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, + 2, 2, 92, 2, 69, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 93, + 94, 95, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 96, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 5, 2, 2, 2, 10, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 97, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 98, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 99, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0x1FFFFFFFFFFFFF, 0xFFFFFFFF1FFFFFFF, 0x1FFFF, 0xFFFFE000FFFFFFFF, + 0x3FFFFFFFFF07FF, 0xFFFFFFFF3FFFFFFF, 0x3EFF0F, 0xFFFF00003FFFFFFF, + 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, 0x7FFFFFFFFFFFFF, + 0xFF003FFFFF, 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, 0x7FFFFFFF, + 0x37FFFF00000000, 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, 0x3FFFFFFEEF0001, + 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x1FFFFFFEFF, 0x3FFFFFFFFFFFFF, + 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0x7FFFFFFFFFFFF, 0xFFFF00801FFFFFFF, + 0x3F, 0xFFFFFFFFFFFFF8, 0xFFFFFFFFFFF8, 0x1FFFFFF0000, 0x7FFFFFFFF8, + 0x47FFFFFFFF0010, 0x7FFFFFFFFFFF8, 0x1400001E, 0xFFFFFFBFFFF, + 0xFFFF01FFBFFFBD7F, 0x23EDFDFFFFF99FE0, 0x3E0010000, 0x780, + 0xFFFFFFFFFFFF, 0xB0, 0x7FFFFFFFFFFF, 0xF000000, 0x10, 0x7FFFFFFFFFF, + 0x7FFFFFF, 0xFFFFFFFFFFF, 0xFFFFFFFF00000000, 0x80000000FFFFFFFF, + 0x407FFFFFFFFF801, 0xFFFFFFFFF0010000, 0x200003CF, 0x1FFFFFFFFFFFFFF, + 0x7FFFFFFFFDFF, 0xFFFC000000000001, 0xFFFF, 0x1FFFFFFFFFB7F, + 0xFFFFFDBF00000040, 0x10003FF, 0x7FFFF00000000, 0x3FFFFFF, 0xF, 0x7F, + 0x3FFFFFFF0000, 0xE0FFFFF80000000F, 0x1001F, 0xFFF80000, 0x300000000, + 0x3FFFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, + 0x1FFF07FFFFFFFFFF, 0x3FF01FF, 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, + 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, + 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD, 0xFFDFFFFFFFDFFFFF, + 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF, 0xFF7, 0x1F, 0xAF7FE96FFFFFFEF, + 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x7FFFFF, 0xFFFF0003FFFFFFFF, + 0x1FFFFFFFF, 0x3FFFFFFF, + ], +}; + +pub const IDEOGRAPHIC: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 3, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 5, 2, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x70003FE000000C0, 0xFFFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFF, + 0xFFFFFFFFFFFF, 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 3, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 5, 6, 1, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 1, 1, + 1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 1, + 1, 1, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFF, 0x7FFFFFFFFFFFF, + 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, 0x7FFFFF, 0x1FFFFFFFFFFFFF, + 0xFFFFFFFF3FFFFFFF, 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, 0x3FFFFFFF, + ], +}; + +pub const JOIN_CONTROL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x3000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const LOGICAL_ORDER_EXCEPTION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1F, 0x4E0000000000000, 0x1A60000000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const LOWERCASE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE00000000, 0x420040000000000, 0xFF7FFFFF80000000, + 0x55AAAAAAAAAAAAAA, 0xD4AAAAAAAAAAAB55, 0xE6512D2A4E243129, + 0xAA29AAAAB5555240, 0x93FAAAAAAAAAAAAA, 0xFFFFFFFFFFFFAA85, + 0x1FFFFFFFFEFFFFF, 0x1F00000003, 0, 0x3C8A000000000020, + 0xFFFFF00000010000, 0x192FAAAAAAE37FFF, 0xFFFF000000000000, + 0xAAAAAAAAFFFFFFFF, 0xAAAAAAAAAAAAA802, 0xAAAAAAAAAAAAD554, + 0xAAAAAAAAAAAA, 0xFFFFFFFF00000000, 0x1FF, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 4, 4, 0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 11, 12, + 0, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, + 5, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 0, 23, 24, 25, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 27, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, + 0, + ], + tree2_level2: &[ + 0, 0xE7FFFFFFFFFF0000, 0x3F00000000000000, 0x1FF, 0xFFFFFFFFFFFFFFFF, + 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAABFEAAAAA, 0xFF00FF003F00FF, + 0x3FFF00FF00FF003F, 0x40DF00FF00FF00FF, 0xDC00FF00CF00DC, + 0x8002000000000000, 0x1FFF0000, 0x321080000008C400, 0xFFFF0000000043C0, + 0x10, 0x3FFFFFF0000, 0xFFFF000000000000, 0x3FDA15627FFFFFFF, + 0x8501AAAAAAAAA, 0x20BFFFFFFFFF, 0x2AAAAAAAAAAA, 0x3AAAAAAA, + 0xAAABAAA800000000, 0x95FFAAAAAAAAAAAA, 0x2A082AAAABA50AA, + 0x700000000000000, 0xFFFF003FF7FFFFFF, 0xF8007F, 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFF0000000000, 0xFFFF, 0xFFFFFFFFF000000, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFC000000, 0xFFFFDFC000, + 0xEBC000000FFFFFFC, 0xFFFFFC000000FFEF, 0xFFFFFFC000000F, 0xFFFFFFC0000, + 0xFC000000FFFFFFC0, 0xFFFFC000000FFFFF, 0xFFFFFFC000000FF, 0xFFFFFFC00000, + 0x3FFFFFFC00, 0xF0000003F7FFFFFC, 0xFFC000000FDFFFFF, 0xFFFF0000003F7FFF, + 0xFFFFFC000000FDFF, 0xBF7, 0xFFFFFFFC00000000, 0xF, + ], +}; + +pub const MATH: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x7000080000000000, 0x5000000040000000, 0x2100000000000, 0x80000000800000, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x73000000270000, 0, 0, 0, 0, 0, 0, 0, 0, + 0x1C0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 9, 9, 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, 14, 15, 16, 17, + 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 18, 19, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 22, 23, 0, 24, + ], + tree2_level2: &[ + 0, 0x1C000000400000, 0x7C00001E00040011, 0x7C00, 0xF8621FFF0000, + 0xF1FBB3103F2FFC84, 0xBFF, 0xF0C37EFFFFFF0000, 0xFFF000302FFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0x300000F00, 0x1000000000000000, 0xBFFFFFF8000000, + 0x7F0010000, 0xF0FFC00300000000, 0xFF001F94000F8CC3, 0x60, 0xE00F00000005, + 0xFFFF000000000000, 0x1F9F, 0x20000000000, 0x17E00000000, + 0x5000000070000800, 0x50000000, 0x1E0400000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 1, 1, 1, 1, 7, 1, 1, 1, 1, 8, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 11, 12, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, + 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, + 0xFFFFFF3FFFFFFFFF, 0xFFFFFFFFFFFFCFFF, 0xAF7FE96FFFFFFEF, + 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x3000000000000, + ], +}; + +pub const NONCHARACTER_CODE_POINT: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF0000, 0xC000000000000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, + ], + tree3_level3: &[ + 0, 0xC000000000000000, + ], +}; + +pub const OTHER_ALPHABETIC: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, + 0xBFFF000000000000, 0xB6, 0x7FF0000, 0x10000FEFFF800, 0, 0x219E1FC00000, + 0xFFFF000000020000, 0, 0x1FFC000000000, 0, + ], + tree2_level1: &[ + 0, 1, 1, 2, 3, 4, 5, 6, 5, 7, 5, 8, 5, 9, 10, 11, 12, 13, 5, 13, 12, 14, + 15, 16, 17, 18, 19, 18, 1, 20, 21, 1, 22, 23, 24, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 25, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 26, 26, 27, 28, 1, 1, + 29, 1, 30, 1, 1, 1, 31, 32, 1, 1, 33, 34, 35, 36, 37, 1, 1, 38, 1, 1, 1, + 39, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 27, 40, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 41, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 42, 43, 1, 1, 1, 1, 1, 44, 1, 45, 46, 47, 48, 49, 1, 50, 51, 52, 53, 1, 1, + 1, 54, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 55, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + ], + tree2_level2: &[ + 0x1EEFF8C00000, 0, 0xFFFF03F8FFF00000, 0xCC0000000000000F, 0xC00E0DFFF, + 0xC00000000000000E, 0xC0080199F, 0x23000000021987, 0x1C00000C00001BBF, + 0xC00C0199F, 0xC000000000000004, 0x801DC7, 0xC00000000000000F, + 0xC00601DDF, 0xC00801DDF, 0xC, 0xC0000FF5F8000, 0x7F2000000000000, 0x2000, + 0x1BF2000000000000, 0xFFFE000000000000, 0x1FFFFFFFFEFFE003, + 0x797FF80000000000, 0x1E0185C3C00000, 0x3000007C, 0x80000000, + 0xC0000000C0000, 0xFFC0000000000000, 0x1FF, 0x20000000060, + 0x1FF0FFF00000000, 0xF800000, 0x1FFFFE7FE00000, 0xFFE000000000001F, 0xF, + 0x33FE00000007, 0x3FF8000000000, 0x3FFFF000000000, 0xC000000000000, + 0x1FFF8000000000, 0x3FFFFFFFFFF, 0xFFFFFFFF00000000, 0xFF0000000000000, + 0xC0000000, 0xF800000000, 0xFFF0000000000003, 0x2F, 0x7C000000000, + 0x7FF80, 0xFFF000000000000F, 0x7FFE0000000000, 0x3008, 0x419D000000000000, + 0x20F80000000000, 0x7F800000000, 0x40000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 2, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, 0, 7, 8, 9, 0, 10, 0, + 0, 11, 12, 13, 0, 0, 14, 15, 16, 17, 0, 0, 18, 19, 20, 21, 22, 0, 23, 0, + 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 25, 26, 27, 0, 0, 0, 0, 0, 28, 0, 29, 0, + 30, 31, 32, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 16, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x7C0000000000000, 0xF06E, 0xF000000000, 0xFF00000000000007, 0x3F, + 0x1FF000000000004, 0x7FF8000000007, 0x60, 0xFFF8000000000007, + 0x409FF00000000000, 0x1FF80000000, 0xC00000000000000F, 0xC0080199F, + 0xFFE0000000000000, 0x3B, 0xFFFF000000000000, 0x3, 0x7F3F800000000000, + 0x30000000, 0x7FFF000000000000, 0x1, 0x3FF80000000000, 0x7FFE0000000, + 0x1FFF00000000000, 0x7BE00000000007FE, 0xFFE0000, 0xFFFC00, + 0x7F7F800000000000, 0x7FFEFFFFFC0000, 0xB47E000000000000, 0x8B, 0x7B7C00, + 0x78000000000000, 0x7F000000000000, 0x7FFFFFFFFFFE0000, 0x40000000, + 0x7DBF9FFFF7F, 0x80, 0xFFFF03FFFFFF03FF, 0x3FF, + ], +}; + +pub const OTHER_DEFAULT_IGNORABLE_CODE_POINT: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x8000, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, + ], + tree2_level2: &[ + 0, 0x180000000, 0x30000000000000, 0x2000000000, 0x1000000000, 0x100000000, + 0x1FF000000000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2, 0, 0, 0, 3, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, + ], + tree3_level3: &[ + 0, 0xFFFFFFFD, 0xFFFFFFFFFFFFFFFF, 0xFFFF000000000000, + ], +}; + +pub const OTHER_GRAPHEME_EXTEND: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 1, 2, 1, 2, 0, 0, 0, 3, 1, 2, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + ], + tree2_level2: &[ + 0, 0x4000000000000000, 0x800000, 0x600004, 0x80008000, 0x1000, + 0xC00000000000, 0xC0000000, + ], + tree3_level1: &[ + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 2, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x4000000000000000, 0x800000, 0x2001000000000000, 0x800000000000, + 0x7C02000000000, 0xFFFFFFFF00000000, 0xFFFFFFFFFFFFFFFF, + ], +}; + +pub const OTHER_ID_CONTINUE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x80000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x3FE0000000000, 0x4000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const OTHER_ID_START: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x60, 0x400001000000, 0x18000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const OTHER_LOWERCASE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x400040000000000, 0, 0, 0, 0, 0, 0, 0, 0x1FF000000000000, + 0x1F00000003, 0, 0x400000000000020, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 10, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFF00000000000, 0x10007FFFFFFFFFF, 0xFFFFFFFFF8000000, + 0x8002000000000000, 0x1FFF0000, 0xFFFF000000000000, 0x3FFFFFF0000, + 0x3000000000000000, 0x30000000, 0x1000000000000, 0x300000000000000, + 0xF0000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const OTHER_MATH: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x40000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x33000000270000, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, + 5, 6, 7, 8, 0, 0, 0, 0, 9, 0, 10, 11, 0, 0, 0, 0, 0, 0, 12, 13, 14, 15, 0, + 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 20, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1C000000400000, 0x6000001E00000001, 0x6000, 0xF8621FFF0000, + 0xF1FBB3103E2FFC84, 0x3E0, 0xF0C33EB6F3E00000, 0x302FEB3FFF, 0xF00, + 0xB0000000000000, 0x400010000, 0xF07FC00300000000, 0x1F94000F8CC1, 0x60, + 0x600F00000005, 0xFFC000000060, 0x1FFFFF8, 0x300000000F000000, + 0x10A00000000, 0x5000000000000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 1, 1, 1, 1, 7, 8, 9, 10, 11, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, + 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, + 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD, 0xFFDFFFFFFFDFFFFF, + 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF, 0xFFFFFFFFFFFFCFF7, + 0xAF7FE96FFFFFFEF, 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, + ], +}; + +pub const OTHER_UPPERCASE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFF00000000, 0xFFC0000000000000, 0xFFFF, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFF000000000000, 0xFFFF03FFFFFF03FF, 0x3FF, + ], +}; + +pub const PATTERN_SYNTAX: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0xFC00FFFE00000000, 0x7800000178000001, 0x88435AFE00000000, + 0x80000000800000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, + 0, 0, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 6, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x7FFF00FFFFFF0000, 0x7FEFFFFE, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFF, 0x3FFFFFFFFFFFFF, 0xFFFFFFFFFFF00000, 0x10001FFFFFF0E, + 0xC000000000000000, 0x60, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const PATTERN_WHITE_SPACE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x100003E00, 0, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x3000000C000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const PREPENDED_CONCATENATION_MARK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0x3F, 0, 0, 0x20000000, 0x8000, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x400000000, + ], + tree3_level1: &[ + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2000000000000000, 0x2000, + ], +}; + +pub const QUOTATION_MARK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x8400000000, 0, 0x800080000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, + ], + tree2_level2: &[ + 0, 0x6000000FF000000, 0x4, 0xE000F000, 0x1E, 0x84, 0xC00000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const RADICAL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 2, 3, 3, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFFFBFFFFFF, 0xFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x3FFFFF, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const REGIONAL_INDICATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + ], + tree2_level2: &[ + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFC000000000, + ], +}; + +pub const SENTENCE_TERMINAL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x8000400200000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0x200, 0, 0xC0000000, 0, 0, 0x100000, 0x7, 0, 0, + 0x200000000000000, + ], + tree2_level1: &[ + 0, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 6, 1, 1, 1, 7, 1, 1, 1, 1, 8, 1, 1, 1, 1, 9, + 1, 1, 10, 1, 1, 11, 12, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 13, 14, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 15, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 17, 1, 1, 1, 1, 18, 1, 1, 19, 1, 1, 1, 1, 1, 20, 1, 18, 21, + 1, 1, 22, 1, 23, 1, 24, 1, 1, 1, 25, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 26, 1, 1, 27, 28, 1, 1, + ], + tree2_level2: &[ + 0x6280000000000000, 0, 0x3000000000, 0xC00, 0x18400000000, 0x400000000000, + 0x60000000000000, 0x208, 0x30, 0xF0000000000, 0xCC000000, + 0x1800000000000000, 0xC000000000000000, 0x3000000000000000, 0x380, + 0x1000400000000000, 0x4, 0x8000000000000000, 0xC000, 0x88000000000000, + 0xC0000000000000, 0x800000000000, 0x300, 0xE0000000, 0x3000000000000, + 0x80000000000, 0xC40000, 0x80004002, 0x200000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 4, 5, 0, 6, 0, 7, 8, 0, 9, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 11, 0, 12, 0, 0, 13, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 14, 15, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 18, 16, 19, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xC00000, 0x3E00000, 0x180, 0xC000000000000000, 0x3, 0xE, 0xC0002060, + 0x1B00000000000000, 0x20000000000, 0x1800, 0xFFFE0C, 0x6, + 0x7000000000000000, 0xC, 0x18000000, 0x180000000000000, 0xC00000000000, + 0x20000000000000, 0x10, 0x1000000, 0x80000000, 0x100, + ], +}; + +pub const SOFT_DOTTED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x60000000000, 0, 0, 0x800000000000, 0, 0, 0, 0, 0x10000000200, + 0x4000020000000, 0, 0, 0, 0, 0x8000000000000, 0, 0x1400000, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 4, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x400000000, 0x11000400000, 0x200000000000, 0x800, 0x2000000000000, + 0x300, 0x1000000000000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xC00000000, 0xC00000, 0xC000000000000C00, 0xC000000000000, + 0xC000000000, 0xC000000, 0xC000, 0xC000000000000C, 0xC0000000000, + 0xC0000000, 0xC0000, + ], +}; + +pub const TERMINAL_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x8C00500200000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0x4000000000000000, 0x80, 0, 0, 0, 0, 0, 0, 0, 0x200, 0x8, 0xC8001000, 0, + 0, 0x100000, 0x17FF, 0, 0, 0x300000000000000, + ], + tree2_level1: &[ + 0, 1, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 4, 2, 2, 5, 2, 2, 2, 2, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 7, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 8, 2, 9, 10, 2, 2, 11, 12, 2, 2, 2, 2, 13, 2, 2, 2, + 2, 14, 2, 2, 15, 2, 2, 16, 17, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 18, 19, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 20, 21, 2, 2, 2, 2, 2, 2, 22, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 17, 2, 2, 2, 2, 23, 2, 2, 24, 2, 2, 2, 2, 2, 25, + 2, 26, 27, 2, 2, 19, 2, 28, 2, 29, 2, 2, 2, 30, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 31, 2, 2, 32, + 33, 2, 2, + ], + tree2_level2: &[ + 0x7FFF000000000000, 0x40000000, 0, 0x3000000000, 0xC000000, 0x7E100, + 0xC00, 0x1FE00000000, 0x600000000000, 0x380000000000, 0x60000000000000, + 0x4700000, 0x33C, 0x30, 0xF0000000000, 0xEC000000, 0xF800000000000000, + 0xC000000000000000, 0x3000000000000000, 0x380, 0x1000400000000000, 0x5002, + 0x6, 0xE000, 0xF8000000000000, 0xC0000000000000, 0xC000, 0x800000000000, + 0xE0000000, 0x3000080000000, 0x80000000000, 0xF70000, 0x8C005002, + 0x1200000000, + ], + tree3_level1: &[ + 0, 1, 2, 3, 3, 3, 4, 3, 3, 3, 3, 5, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 0, 0, 4, 0, 5, 6, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 9, 10, 11, 0, 12, 0, 13, 14, + 0, 15, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 17, 0, 18, 0, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 25, 0, 26, 27, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x80000000, 0x10000, 0x800000, 0xC00000, 0x3F000000000000, + 0xFC00000000000000, 0x1E000000, 0x3E00000, 0x3F80, 0xC000000000000000, + 0x3, 0xE, 0xC0002060, 0x1F00000000000000, 0x20000000000, 0x8003800, + 0xFFFE3C, 0x6, 0x7000000000000000, 0xC, 0x618000000, 0x200000000000E, + 0x180000000000000, 0x1F000000000000, 0xC00000000000, 0x20000000000000, + 0x380000000000000, 0x10, 0x1800000, 0x780, + ], +}; + +pub const UNIFIED_IDEOGRAPH: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0x39A801AC000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 3, 4, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 4, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0x7FFFFF, 0x1FFFFFFFFFFFFF, 0xFFFFFFFF3FFFFFFF, + 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, + ], +}; + +pub const UPPERCASE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE, 0, 0x7F7FFFFF, 0xAA55555555555555, 0x2B555555555554AA, + 0x11AED2D5B1DBCED6, 0x55D255554AAAA490, 0x6C05555555555555, 0x557A, 0, 0, + 0, 0x8045000000000000, 0xFFBFFFED740, 0xE6905555551C8000, 0xFFFFFFFFFFFF, + 0x5555555500000000, 0x5555555555555401, 0x5555555555552AAB, + 0xFFFE555555555555, 0x7FFFFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 0, 0, + 0, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, + 5, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 20, 0, 21, 22, 23, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0x20BF, 0x3FFFFFFFFFFFFF, 0xE7FFFFFFFFFF0000, + 0x5555555555555555, 0x5555555540155555, 0xFF00FF003F00FF00, + 0xFF00AA003F00, 0xF00000000000000, 0xF001F000F000F00, 0xC00F3D503E273884, + 0xFFFF00000020, 0x8, 0xFFC0000000000000, 0xFFFF, 0x7FFFFFFFFFFF, + 0xC025EA9D00000000, 0x4280555555555, 0x155555555555, 0x5555555, + 0x5554555400000000, 0x6A00555555555555, 0x15F7D5555452855, + 0x7FFFFFE00000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 24, 25, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFF, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF00000000, 0xFFFFFFFF, 0xFFF0000003FFFFFF, 0xFFFFFF0000003FFF, + 0x3FDE64D0000003, 0x3FFFFFF0000, 0x7B0000001FDFE7B0, 0xFFFFF0000001FC5F, + 0x3FFFFFF0000003F, 0x3FFFFFF00000, 0xF0000003FFFFFF00, 0xFFFF0000003FFFFF, + 0xFFFFFF00000003FF, 0x7FFFFFC00000001, 0x1FFFFFF0000000, 0x7FFFFFC00000, + 0x1FFFFFF0000, 0x400, 0x3FFFFFFFF, 0xFFFF03FFFFFF03FF, 0x3FF, + ], +}; + +pub const VARIATION_SELECTOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x3800, 0xFFFF, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const WHITE_SPACE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x100003E00, 0, 0x100000020, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1, 0x8300000007FF, 0x80000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const XID_CONTINUE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x3FF000000000000, 0x7FFFFFE87FFFFFE, 0x4A0040000000000, + 0xFF7FFFFFFF7FFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, + 0xFFFFFFFFFFFFFFFF, 0xB8DFFFFFFFFFFFFF, 0xFFFFFFFBFFFFD7C0, + 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFCFB, 0xFFFFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFFF, + 0xFFFFFFFF027FFFFF, 0xBFFFFFFFFFFE01FF, 0x787FFFFFF00B6, + 0xFFFFFFFF07FF0000, 0xFFFFC3FFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0x9FFFFDFF9FEFFFFF, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFFE7FF, + 0x3FFFFFFFFFFFF, 0x243FFFFFFFFFFFFF, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 4, 32, 33, 34, 4, 4, 4, 4, 4, + 35, 36, 37, 38, 39, 40, 41, 42, 4, 4, 4, 4, 4, 4, 4, 4, 43, 44, 45, 46, + 47, 4, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 4, 61, 4, 62, + 63, 64, 65, 66, 4, 4, 4, 67, 4, 4, 4, 4, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 79, 80, 4, 81, 82, 83, 84, 85, 60, 60, 60, + 60, 60, 60, 60, 60, 86, 42, 87, 88, 89, 4, 90, 91, 60, 60, 60, 60, 60, 60, + 60, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 52, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 92, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 93, 94, 4, 4, 4, 4, 95, 96, 4, 97, 98, 4, 99, 100, 101, 62, + 4, 102, 103, 104, 4, 105, 106, 107, 4, 108, 109, 110, 4, 111, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 112, 113, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, + 60, 60, 60, 60, 60, 4, 4, 4, 4, 4, 103, 4, 114, 115, 116, 97, 117, 4, 118, + 4, 4, 119, 120, 121, 122, 123, 124, 4, 125, 126, 127, 128, 129, + ], + tree2_level2: &[ + 0x3FFFFFFFFFFF, 0x7FF0FFFFFFF, 0x3FDFFFFF00000000, 0xFFFFFFFBFFF80000, + 0xFFFFFFFFFFFFFFFF, 0xFFFEFFCFFFFFFFFF, 0xF3C5FDFFFFF99FEF, + 0x5003FFCFB080799F, 0xD36DFDFFFFF987EE, 0x3FFFC05E023987, + 0xF3EDFDFFFFFBBFEE, 0xFE00FFCF00013BBF, 0xF3EDFDFFFFF99FEE, + 0x2FFCFB0C0399F, 0xC3FFC718D63DC7EC, 0xFFC000813DC7, 0xE3FFFDFFFFFDDFFF, + 0xFFCF07603DDF, 0xF3EFFDFFFFFDDFEF, 0x6FFCF40603DDF, 0xFFFFFFFFFFFDDFEF, + 0xFC00FFCF80F07DDF, 0x2FFBFFFFFC7FFFEC, 0xCFFC0FF5F847F, + 0x7FFFFFFFFFFFFFE, 0x3FF7FFF, 0x3BFFECAEFEF02596, 0xF3FF3F5F, + 0xC2A003FF03000001, 0xFFFE1FFFFFFFFEFF, 0x1FFFFFFFFEFFFFDF, 0x40, + 0xFFFFFFFFFFFF03FF, 0xFFFFFFFF3FFFFFFF, 0xF7FFFFFFFFFF20BF, + 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, + 0xFFFFFFFFFF3DFFFF, 0x3FE00E7FFFFFF, 0xFFFFFFFF0000FFFF, + 0x3F3FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, + 0xFFFFFFFF07FFFFFE, 0x1FFC7FFFFFFFFFF, 0x1FFFFF001FDFFF, 0xDDFFF000FFFFF, + 0x3FF308FFFFF, 0xFFFFFFFF03FF3800, 0x1FFFFFFFFFFFFFF, 0xFFFF07FFFFFFFFFF, + 0x3FFFFFFFFFFFFF, 0xFFF0FFF7FFFFFFF, 0x1F3FFFFFFFFFC0, 0xFFFF0FFFFFFFFFFF, + 0x7FF03FF, 0xFFFFFFFF0FFFFFFF, 0x9FFFFFFF7FFFFFFF, 0x3FFF008003FF03FF, 0, + 0xFF80003FF0FFF, 0xFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFE3FF, + 0xE7FFFFFFFFFF01FF, 0x3FFFFFFFFF70000, 0xFBFFFFFFFFFFFFFF, + 0xFFFFFFFF3F3FFFFF, 0x3FFFFFFFAAFF3F3F, 0x5FDFFFFFFFFFFFFF, + 0x1FDC1FFF0FCF1FDC, 0x8000000000000000, 0x8002000000100001, 0x1FFF0000, + 0x1FFE21FFF0000, 0xF3FFFD503F2FFC84, 0xFFFFFFFF000043E0, 0x1FF, + 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF, 0xFF81FFFFFFFFF, + 0xFFFF20BFFFFFFFFF, 0x800080FFFFFFFFFF, 0x7F7F7F7F007FFFFF, + 0xFFFFFFFF7F7F7F7F, 0x1F3EFFFE000000E0, 0xFFFFFFFEE67FFFFF, + 0xF7FFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFE0, 0x7FFFFFF00007FFF, + 0xFFFF000000000000, 0xFFFFFFFFFFFF, 0x1FFF, 0x3FFFFFFFFFFF0000, + 0xFFFFFFF1FFF, 0xBFF0FFFFFFFFFFFF, 0x3FFFFFFFFFFFF, 0xFFFFFFFCFF800000, + 0x3FFFFFFFFFFF9FF, 0xFF80000000000000, 0xFFFFFFFFFF, 0xE8FFFFFF03FF003F, + 0xFFFF3FFFFFFFFFFF, 0x1FFFFFFF000FFFFF, 0x7FFFFFFF03FF8001, + 0x7FFFFFFFFFFFFF, 0xFC7FFFFF03FF3FFF, 0x7CFFFF38000007, + 0xFFFF7F7F007E7E7E, 0xFFFF003FF7FFFFFF, 0x3FF37FFFFFFFFFF, + 0xFFFF000FFFFFFFFF, 0xFFFFFFFFFFFF87F, 0x3FFFFFF, 0x5F7FFDFFE0F8007F, + 0xFFFFFFFFFFFFFFDB, 0xFFFFFFFFFFF80000, 0xFFFFFFF03FFFFFFF, + 0x3FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, + 0x3FF0000000000FF, 0x18FFFF0000FFFF, 0xAA8A00000000E000, + 0x1FFFFFFFFFFFFFFF, 0x87FFFFFE03FF0000, 0xFFFFFFC007FFFFFE, + 0x7FFFFFFFFFFFFFFF, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 12, 13, 14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 5, 4, 6, 4, 4, 7, 8, 9, 10, 11, 12, 2, 2, 13, 14, 15, 16, + 4, 4, 2, 2, 2, 2, 17, 18, 4, 4, 19, 20, 21, 22, 23, 4, 24, 4, 25, 26, 27, + 28, 29, 30, 31, 4, 2, 32, 33, 33, 34, 4, 4, 4, 4, 4, 4, 4, 35, 36, 4, 4, + 2, 37, 3, 38, 39, 40, 2, 41, 42, 4, 43, 44, 45, 46, 4, 4, 2, 47, 2, 48, 4, + 4, 49, 50, 2, 51, 52, 53, 54, 4, 4, 4, 3, 4, 55, 56, 4, 4, 4, 4, 57, 58, + 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 2, 69, 2, 2, 2, 70, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 69, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 71, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 60, 72, 4, 73, 17, 74, 75, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 2, 76, + 77, 78, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 79, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 21, 80, 2, 2, 2, 2, 2, 81, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 2, 82, 83, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 84, 85, 4, 4, 86, 4, 4, 4, 4, 4, 4, 2, 87, 88, 89, 90, 91, 2, + 2, 2, 2, 92, 93, 94, 95, 96, 97, 4, 4, 4, 4, 4, 4, 4, 4, 98, 99, 100, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 101, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 2, 2, 2, 102, 2, 103, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 104, 105, 106, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 107, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 11, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 108, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 109, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 110, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 111, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0x1FFFFFFFFFFFFF, 0x2000000000000000, 0xFFFFFFFF1FFFFFFF, 0x10001FFFF, + 0xFFFFE000FFFFFFFF, 0x7FFFFFFFFFF07FF, 0xFFFFFFFF3FFFFFFF, 0x3EFF0F, + 0xFFFF03FF3FFFFFFF, 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, + 0x7FFFFFFFFFFFFF, 0xFF003FFFFF, 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, + 0x7FFFFFFF, 0x37FFFF00000000, 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, + 0x873FFFFFFEEFF06F, 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x7FFFFFFEFF, + 0x3FFFFFFFFFFFFF, 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0x7FFFFFFFFFFFF, + 0x3FF00FFFFFFFFFF, 0xFFFF00801FFFFFFF, 0x1FFFF, 0x8000FFC00000007F, + 0x3FF01FFFFFF0000, 0xFFDFFFFFFFFFFFFF, 0x4FFFFFFFFF0070, 0x17FF1E1F, + 0x40FFFFFFFFFBFFFF, 0xFFFF01FFBFFFBD7F, 0x3FF07FFFFFFFFFF, + 0xFBEDFDFFFFF99FEF, 0x1F1FCFE081399F, 0x43FF07FF, 0x3FF00BF, + 0xFF3FFFFFFFFFFFFF, 0x3F000001, 0x3FF0011, 0xFFFFFFFFFFFFFF, 0x3FF, + 0x3FF0FFFE7FFFFFF, 0xFFFFFFFF00000000, 0x800003FFFFFFFFFF, + 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0080, 0x23FFFFCF, 0x1FFFFFFFFFFFFFF, + 0xFF7FFFFFFFFFFDFF, 0xFFFC000003FF0001, 0x7FFEFFFFFCFFFF, + 0xB47FFFFFFFFFFB7F, 0xFFFFFDBF03FF00FF, 0x3FF01FB7FFF, 0x7FFFFF00000000, + 0x3FFFFFF, 0x7FFFFFFFFFFF, 0xF, 0x7F, 0x3FF7FFFFFFF, 0x1F3FFFFFFF0000, + 0xE0FFFFF803FF000F, 0xFFFF, 0x7FFFFFFFFFFF001F, 0xFFFF8000, 0x300000000, + 0x3FFFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, + 0x1FFF07FFFFFFFFFF, 0x63FF01FF, 0xF807E3E000000000, 0x3C0000000FE7, 0x1C, + 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, + 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, + 0xF7FFFFFFF7FFFFFD, 0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, + 0xFFFFFDFFFFFFFDFF, 0xFFFFFFFFFFFFCFF7, 0xF87FFFFFFFFFFFFF, + 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F, 0x7F001F, 0x3FF07FF, + 0xAF7FE96FFFFFFEF, 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x7FFFFF, + 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, 0x3FFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const XID_START: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x420040000000000, 0xFF7FFFFFFF7FFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, 0, 0xB8DF000000000000, + 0xFFFFFFFBFFFFD740, 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFF027FFFFF, 0x1FF, 0x787FFFFFF0000, + 0xFFFFFFFF00000000, 0xFFFEC000000007FF, 0xFFFFFFFFFFFFFFFF, + 0x9C00C060002FFFFF, 0xFFFFFFFD0000, 0xFFFFFFFFFFFFE000, 0x2003FFFFFFFFF, + 0x43007FFFFFFFC00, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 23, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 34, 34, 34, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 34, 34, 34, 34, 34, 34, 34, 34, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 3, 61, + 62, 63, 64, 65, 66, 67, 68, 34, 34, 34, 3, 34, 34, 34, 34, 69, 70, 71, 72, + 3, 73, 74, 3, 75, 76, 77, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 78, 79, 34, 80, 81, 82, 83, 84, 3, 3, 3, 3, 3, 3, 3, 3, 85, 42, 86, 87, + 88, 34, 89, 90, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 53, 3, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 91, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 92, 93, 34, 34, 34, 34, 94, 95, 96, + 91, 97, 34, 98, 99, 100, 48, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 34, 113, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 114, 115, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 116, 34, 117, 118, + 119, 120, 121, 34, 122, 34, 34, 123, 124, 125, 126, 3, 127, 34, 128, 129, + 130, 131, 132, + ], + tree2_level2: &[ + 0x110043FFFFF, 0x7FF01FFFFFF, 0x3FDFFFFF00000000, 0, 0x23FFFFFFFFFFFFF0, + 0xFFFE0003FF010000, 0x23C5FDFFFFF99FE1, 0x10030003B0004000, + 0x36DFDFFFFF987E0, 0x1C00005E000000, 0x23EDFDFFFFFBBFE0, + 0x200000300010000, 0x23EDFDFFFFF99FE0, 0x20003B0000000, 0x3FFC718D63DC7E8, + 0x10000, 0x23FFFDFFFFFDDFE0, 0x307000000, 0x23EFFDFFFFFDDFE1, + 0x6000340000000, 0x27FFFFFFFFFDDFE0, 0xFC00000380704000, + 0x2FFBFFFFFC7FFFE0, 0x7F, 0x5FFFFFFFFFFFE, 0x2005ECAEFEF02596, 0xF000005F, + 0x1, 0x1FFFFFFFFEFF, 0x1F00, 0x800007FFFFFFFFFF, 0xFFE1C0623C3F0000, + 0xFFFFFFFF00004003, 0xF7FFFFFFFFFF20BF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, + 0xFFFFFFFFFF3DFFFF, 0x7FFFFFF, 0xFFFFFFFF0000FFFF, 0x3F3FFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, 0xFFFFFFFF07FFFFFE, + 0x1FFC7FFFFFFFFFF, 0x3FFFF0003DFFF, 0x1DFFF0003FFFF, 0xFFFFFFFFFFFFF, + 0x10800000, 0xFFFFFFFF00000000, 0x1FFFFFFFFFFFFFF, 0xFFFF05FFFFFFFFFF, + 0x3FFFFFFFFFFFFF, 0x7FFFFFFF, 0x1F3FFFFFFF0000, 0xFFFF0FFFFFFFFFFF, 0x3FF, + 0xFFFFFFFF007FFFFF, 0x1FFFFF, 0x8000000000, 0xFFFFFFFFFFFE0, 0xFE0, + 0xFC00C001FFFFFFF8, 0x3FFFFFFFFF, 0xFFFFFFFFF, 0x3FFFFFFFFC00E000, + 0xE7FFFFFFFFFF01FF, 0x63DE0000000000, 0xFFFFFFFF3F3FFFFF, + 0x3FFFFFFFAAFF3F3F, 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, + 0x8002000000000000, 0x1FFF0000, 0xF3FFFD503F2FFC84, 0xFFFFFFFF000043E0, + 0x1FF, 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF, 0xC781FFFFFFFFF, + 0xFFFF20BFFFFFFFFF, 0x80FFFFFFFFFF, 0x7F7F7F7F007FFFFF, 0x7F7F7F7F, + 0x1F3E03FE000000E0, 0xFFFFFFFEE07FFFFF, 0xF7FFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFE0, 0x7FFFFFF00007FFF, 0xFFFF000000000000, 0xFFFFFFFFFFFF, + 0x1FFF, 0x3FFFFFFFFFFF0000, 0xC00FFFF1FFF, 0x80007FFFFFFFFFFF, + 0xFFFFFFFF3FFFFFFF, 0xFFFFFFFCFF800000, 0x3FFFFFFFFFFF9FF, + 0xFF80000000000000, 0x7FFFFF7BB, 0xFFFFFFFFFFFFC, 0x68FC000000000000, + 0xFFFF003FFFFFFC00, 0x1FFFFFFF0000007F, 0x7FFFFFFFFFFF0, + 0x7C00FFDF00008000, 0x1FFFFFFFFFF, 0xC47FFFFF00000FF7, 0x3E62FFFFFFFFFFFF, + 0x1C07FF38000005, 0xFFFF7F7F007E7E7E, 0xFFFF003FF7FFFFFF, 0x7FFFFFFFF, + 0xFFFF000FFFFFFFFF, 0xFFFFFFFFFFFF87F, 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, + 0x5F7FFDFFA0F8007F, 0xFFFFFFFFFFFFFFDB, 0x3FFFFFFFFFFFF, + 0xFFFFFFFFFFF80000, 0xFFFFFFF03FFFFFFF, 0x3FFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, 0x3FF0000000000FF, + 0xAA8A000000000000, 0x1FFFFFFFFFFFFFFF, 0x7FFFFFE00000000, + 0xFFFFFFC007FFFFFE, 0x7FFFFFFF3FFFFFFF, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 12, 13, 14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 5, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 2, 2, 12, 13, 14, 15, 4, + 4, 2, 2, 2, 2, 16, 17, 4, 4, 18, 19, 20, 21, 22, 4, 23, 4, 24, 25, 26, 27, + 28, 29, 30, 4, 2, 31, 32, 32, 15, 4, 4, 4, 4, 4, 4, 4, 33, 34, 4, 4, 35, + 4, 36, 37, 38, 39, 40, 41, 42, 4, 43, 20, 44, 45, 4, 4, 5, 46, 47, 48, 4, + 4, 49, 50, 47, 51, 52, 4, 53, 4, 4, 4, 54, 4, 55, 56, 4, 4, 4, 4, 57, 58, + 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 2, 49, 2, 2, 2, 69, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 49, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 70, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 60, 20, 4, 71, 47, 72, 63, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 2, 73, + 74, 75, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 76, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 20, 77, 2, 2, 2, 2, 2, 78, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 2, 79, 80, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 81, 82, 83, 84, 85, 2, 2, + 2, 2, 86, 87, 88, 89, 90, 91, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, + 2, 2, 92, 2, 69, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 93, + 94, 95, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 96, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 5, 2, 2, 2, 10, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 97, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 98, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 99, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0x1FFFFFFFFFFFFF, 0xFFFFFFFF1FFFFFFF, 0x1FFFF, 0xFFFFE000FFFFFFFF, + 0x3FFFFFFFFF07FF, 0xFFFFFFFF3FFFFFFF, 0x3EFF0F, 0xFFFF00003FFFFFFF, + 0xFFFFFFFFF0FFFFF, 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, 0x7FFFFFFFFFFFFF, + 0xFF003FFFFF, 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, 0x7FFFFFFF, + 0x37FFFF00000000, 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, 0x3FFFFFFEEF0001, + 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x1FFFFFFEFF, 0x3FFFFFFFFFFFFF, + 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0x7FFFFFFFFFFFF, 0xFFFF00801FFFFFFF, + 0x3F, 0xFFFFFFFFFFFFF8, 0xFFFFFFFFFFF8, 0x1FFFFFF0000, 0x7FFFFFFFF8, + 0x47FFFFFFFF0010, 0x7FFFFFFFFFFF8, 0x1400001E, 0xFFFFFFBFFFF, + 0xFFFF01FFBFFFBD7F, 0x23EDFDFFFFF99FE0, 0x3E0010000, 0x780, + 0xFFFFFFFFFFFF, 0xB0, 0x7FFFFFFFFFFF, 0xF000000, 0x10, 0x7FFFFFFFFFF, + 0x7FFFFFF, 0xFFFFFFFFFFF, 0xFFFFFFFF00000000, 0x80000000FFFFFFFF, + 0x407FFFFFFFFF801, 0xFFFFFFFFF0010000, 0x200003CF, 0x1FFFFFFFFFFFFFF, + 0x7FFFFFFFFDFF, 0xFFFC000000000001, 0xFFFF, 0x1FFFFFFFFFB7F, + 0xFFFFFDBF00000040, 0x10003FF, 0x7FFFF00000000, 0x3FFFFFF, 0xF, 0x7F, + 0x3FFFFFFF0000, 0xE0FFFFF80000000F, 0x1001F, 0xFFF80000, 0x300000000, + 0x3FFFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, + 0x1FFF07FFFFFFFFFF, 0x3FF01FF, 0xFFFFFFFFFFDFFFFF, 0xEBFFDE64DFFFFFFF, + 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, 0xFFFFFFFFFFFDFC5F, + 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD, 0xFFDFFFFFFFDFFFFF, + 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF, 0xFF7, 0x1F, 0xAF7FE96FFFFFFEF, + 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x7FFFFF, 0xFFFF0003FFFFFFFF, + 0x1FFFFFFFF, 0x3FFFFFFF, + ], +}; diff --git a/vendor/pest/src/unicode/category.rs b/vendor/pest/src/unicode/category.rs new file mode 100644 index 000000000..87532aabd --- /dev/null +++ b/vendor/pest/src/unicode/category.rs @@ -0,0 +1,3549 @@ +// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY: +// +// ucd-generate.exe general-category --trie-set ./target/ucd/ +// +// ucd-generate is available on crates.io. + +pub const BY_NAME: &'static [(&'static str, &'static ::ucd_trie::TrieSet)] = &[ + ("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 ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x20000000000000, 0xFF7FFFFFFF7FFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xF7FFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFEFFFFF, 0, 0, 0xB8CF000000000000, 0xFFFFFFFBFFFFD740, + 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFFF, + 0xFFFFFFFF007FFFFF, 0x1FF, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 6, 7, 0, 8, 8, 8, 8, 9, 10, 11, 12, 0, 0, 0, + 0, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, 8, + 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 0, 22, 23, 24, 25, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 30, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0xE7FFFFFFFFFF20BF, 0x3F3FFFFFFFFFFFFF, + 0xE7FFFFFFFFFF01FF, 0xFFFFFFFFFFF, 0xFEFFF80000000000, 0x7FFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF3F3FFFFF, 0x3FFFFFFFAAFF3F3F, + 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, 0xF21FBD503E2FFC84, 0x43E0, 0x18, + 0xFFFF7FFFFFFFFFFF, 0xCFFFFFFF7FFFFFFF, 0xC781FFFFFFFFF, 0x20BFFFFFFFFF, + 0x3FFFFFFFFFFF, 0xFFFFFFF, 0xFFFFFFFC00000000, 0xFFFEFFFFFFFFFFFF, + 0x3FFFFFFFFFF78FF, 0x400000000000000, 0xFFFF000000000000, + 0xFFFF003F07FFFFFF, 0xF8007F, 0x7FFFFFE00000000, 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 8, 9, + 10, 11, 12, 1, 1, 1, 1, 13, 14, 15, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0xFFFF, 0xFFFF000000000000, 0xFFFFFFFFF0FFFFF, + 0x7FFFFFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFFF, 0xFFFFFFFFFFDFFFFF, + 0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, + 0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD, + 0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF, 0xFF7, 0xF, + ], +}; + +pub const CLOSE_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x20000000000, 0x2000000020000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 7, 0, 0, 0, 0, 0, 0, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 13, 14, 0, 0, 15, 16, 0, 0, + ], + tree2_level2: &[ + 0, 0x2800000000000000, 0x10000000, 0x4000000000000040, 0x4000, + 0x40000000A00, 0x2AAA0000000000, 0xAA8000000040, 0x1555550, + 0x200000000A000000, 0x2A800000000, 0xCAA2AA00, 0x4000000000000000, + 0x5540000001000000, 0x54000115, 0x2000000000000200, 0x920000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const CONNECTOR_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0, 0, 1, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x8000000000000000, 0x100001, 0x18000000000000, 0xE000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const CONTROL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0xFFFFFFFF, 0x8000000000000000, 0xFFFFFFFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + ], + tree2_level2: &[ + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const CURRENCY_SYMBOL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x1000000000, 0, 0x3C00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0x8000, 0, 0x800, 0, 0, 0, 0, 0, 0, 0xC000000000000000, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 9, 0, 0, 10, 0, 0, 11, + ], + tree2_level2: &[ + 0, 0x80C000000000000, 0x2000000000000, 0x200000000000000, + 0x8000000000000000, 0x8000000, 0xFFFFFFFF00000000, 0x100000000000000, + 0x1000000000000000, 0x20000000000, 0x10, 0x6300000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x1000000000000, + ], +}; + +pub const DASH_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x200000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0x4000000000000400, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4, 1, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 0, 0, 9, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1, 0x40, 0x3F0000, 0xC00000004800000, 0x1000010000000, 0x100000000, + 0x6000000000000, 0x801000000, 0x2000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const DECIMAL_NUMBER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x3FF000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0x3FF00000000, 0, 0x3FF000000000000, 0, 0, 0, 0x3FF, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 2, 0, 2, 3, 0, 0, 0, 0, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 5, 0, 2, 0, 0, 6, + 0, 0, 2, 7, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 0, 0, 8, 0, 2, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFC000000000, 0x3FF0000, 0x3FF00000000, 0x3FF, 0xFFC0, 0x3FF03FF, + 0x3FF000000000000, 0x3FF000003FF0000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 4, 0, 0, 5, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 0, 0, 5, 0, 6, 2, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x3FF00000000, 0x3FF000000000000, 0xFFC000000000, 0xFFC0000000000000, + 0x3FF0000, 0x3FF, 0xFFFFFFFFFFFFC000, + ], +}; + +pub const ENCLOSING_MARK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x300, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x4000000000000000, 0x1DE0000000, 0x7000000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const FINAL_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x800000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x400000022000000, 0x220002428, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const FORMAT: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x200000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0x1000003F, 0, 0, 0x20000000, 0x8000, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 6, + ], + tree2_level2: &[ + 0, 0x400000000, 0x4000, 0x7C000000F800, 0xFFDF00000000, + 0x8000000000000000, 0xE00000000000000, + ], + tree3_level1: &[ + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2000000000000000, 0x2000, 0xF00000000, 0x7F8000000000000, + 0xFFFFFFFF00000002, 0xFFFFFFFFFFFFFFFF, + ], +}; + +pub const INITIAL_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x80000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x200000099000000, 0x110001214, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const LETTER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE07FFFFFE, 0x420040000000000, 0xFF7FFFFFFF7FFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0x501F0003FFC3, 0, 0xBCDF000000000000, + 0xFFFFFFFBFFFFD740, 0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFC03, 0xFFFFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFFF, 0xFFFFFFFF027FFFFF, 0x1FF, 0x787FFFFFF0000, + 0xFFFFFFFF00000000, 0xFFFEC000000007FF, 0xFFFFFFFFFFFFFFFF, + 0x9C00C060002FFFFF, 0xFFFFFFFD0000, 0xFFFFFFFFFFFFE000, 0x2003FFFFFFFFF, + 0x43007FFFFFFFC00, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 23, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 34, 34, 34, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 34, 34, 34, 34, 34, 34, 34, 34, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 3, 61, + 62, 63, 64, 65, 66, 67, 68, 34, 34, 34, 3, 34, 34, 34, 34, 69, 70, 71, 72, + 3, 73, 74, 3, 75, 76, 77, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 78, 79, 34, 80, 81, 82, 83, 84, 85, 3, 3, 3, 3, 3, 3, 3, 86, 42, 87, 88, + 89, 34, 90, 91, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 53, 3, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 92, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 93, 94, 34, 34, 34, 34, 95, 96, 97, + 64, 98, 34, 99, 100, 101, 48, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 34, 114, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 115, 116, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 117, 34, 118, 119, + 120, 121, 122, 34, 34, 34, 34, 123, 124, 125, 126, 3, 127, 34, 128, 129, + 130, 131, 132, + ], + tree2_level2: &[ + 0x110043FFFFF, 0x7FF01FFFFFF, 0x3FDFFFFF00000000, 0, 0x23FFFFFFFFFFFFF0, + 0xFFFE0003FF010000, 0x23C5FDFFFFF99FE1, 0x10030003B0004000, + 0x36DFDFFFFF987E0, 0x1C00005E000000, 0x23EDFDFFFFFBBFE0, + 0x200000300010000, 0x23EDFDFFFFF99FE0, 0x20003B0000000, 0x3FFC718D63DC7E8, + 0x10000, 0x23FFFDFFFFFDDFE0, 0x307000000, 0x23EFFDFFFFFDDFE1, + 0x6000340000000, 0x27FFFFFFFFFDDFE0, 0xFC00000380704000, + 0x2FFBFFFFFC7FFFE0, 0x7F, 0xDFFFFFFFFFFFE, 0x200DECAEFEF02596, 0xF000005F, + 0x1, 0x1FFFFFFFFEFF, 0x1F00, 0x800007FFFFFFFFFF, 0xFFE1C0623C3F0000, + 0xFFFFFFFF00004003, 0xF7FFFFFFFFFF20BF, 0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFF3D7F3DFF, 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, + 0xFFFFFFFFFF3DFFFF, 0x7FFFFFF, 0xFFFFFFFF0000FFFF, 0x3F3FFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, 0xFFFFFFFF07FFFFFE, + 0x1FE07FFFFFFFFFF, 0x3FFFF0003DFFF, 0x1DFFF0003FFFF, 0xFFFFFFFFFFFFF, + 0x10800000, 0xFFFFFFFF00000000, 0x1FFFFFFFFFFFFFF, 0xFFFF05FFFFFFFF9F, + 0x3FFFFFFFFFFFFF, 0x7FFFFFFF, 0x1F3FFFFFFF0000, 0xFFFF0FFFFFFFFFFF, 0x3FF, + 0xFFFFFFFF007FFFFF, 0x1FFFFF, 0x8000000000, 0xFFFFFFFFFFFE0, 0xFE0, + 0xFC00C001FFFFFFF8, 0x3FFFFFFFFF, 0xFFFFFFFFF, 0x3FFFFFFFFC00E000, + 0xE7FFFFFFFFFF01FF, 0x63DE0000000000, 0xFFFFFFFF3F3FFFFF, + 0x3FFFFFFFAAFF3F3F, 0x5FDFFFFFFFFFFFFF, 0x1FDC1FFF0FCF1FDC, + 0x8002000000000000, 0x1FFF0000, 0xF3FFBD503E2FFC84, 0x43E0, 0x18, + 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF, 0xC781FFFFFFFFF, + 0xFFFF20BFFFFFFFFF, 0x80FFFFFFFFFF, 0x7F7F7F7F007FFFFF, 0x7F7F7F7F, + 0x800000000000, 0x183E000000000060, 0xFFFFFFFEE07FFFFF, + 0xF7FFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFE0, 0x7FFFFFF00007FFF, + 0xFFFF000000000000, 0xFFFFFFFFFFFF, 0x1FFF, 0x3FFFFFFFFFFF0000, + 0xC00FFFF1FFF, 0x80007FFFFFFFFFFF, 0xFFFFFFFF3FFFFFFF, 0xFFFFFFFCFF800000, + 0x3FFFFFFFFFFF9FF, 0xFF80000000000000, 0x7FFFFF7BB, 0xFFFFFFFFFFFFC, + 0x68FC000000000000, 0xFFFF003FFFFFFC00, 0x1FFFFFFF0000007F, + 0x7FFFFFFFFFFF0, 0x7C00FFDF00008000, 0x1FFFFFFFFFF, 0xC47FFFFF00000FF7, + 0x3E62FFFFFFFFFFFF, 0x1C07FF38000005, 0xFFFF7F7F007E7E7E, + 0xFFFF003FF7FFFFFF, 0x7FFFFFFFF, 0xFFFF000FFFFFFFFF, 0xFFFFFFFFFFFF87F, + 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, 0x5F7FFDFFA0F8007F, 0xFFFFFFFFFFFFFFDB, + 0x3FFFFFFFFFFFF, 0xFFFFFFFFFFF80000, 0x3FFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, 0xFFF0000000000FF, + 0xFFDF000000000000, 0x1FFFFFFFFFFFFFFF, 0x7FFFFFE00000000, + 0xFFFFFFC007FFFFFE, 0x7FFFFFFFFFFFFFFF, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 12, 13, 14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10, 2, 2, 11, 12, 13, 14, 4, + 4, 2, 2, 2, 2, 15, 16, 4, 4, 17, 18, 19, 20, 21, 4, 22, 4, 23, 24, 25, 26, + 27, 28, 29, 4, 2, 30, 31, 31, 14, 4, 4, 4, 4, 4, 4, 4, 32, 33, 4, 4, 34, + 4, 35, 36, 37, 38, 39, 40, 41, 4, 42, 19, 43, 44, 4, 4, 45, 46, 47, 48, 4, + 4, 49, 50, 47, 51, 52, 4, 53, 4, 4, 4, 54, 4, 55, 56, 4, 4, 4, 4, 57, 58, + 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 4, 4, 2, 2, 2, 69, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 49, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 70, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, + 60, 19, 4, 71, 47, 72, 63, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 2, 73, + 74, 75, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 76, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 31, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 19, 77, 2, 2, 2, 2, 2, 78, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 2, 79, 80, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 81, 82, 83, 84, 85, 2, 2, + 2, 2, 86, 87, 88, 89, 90, 91, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, + 2, 2, 92, 2, 69, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 93, + 94, 95, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 96, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 45, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 97, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 98, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 99, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0xFFFFFFFF1FFFFFFF, 0x1FFFF, 0xFFFFE000FFFFFFFF, 0x3FFFFFFFFF03FD, + 0xFFFFFFFF3FFFFFFF, 0xFF0F, 0xFFFF00003FFFFFFF, 0xFFFFFFFFF0FFFFF, + 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, 0x7FFFFFFFFFFFFF, 0xFF003FFFFF, + 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, 0x7FFFFFFF, 0x37FFFF00000000, + 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, 0x3FFFFFFEEF0001, + 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x1FFFFFFEFF, 0x3FFFFFFFFFFFFF, + 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0x7FFFFFFFFFFFF, 0xFFFF00801FFFFFFF, + 0x3F, 0xFFFFFFFFFFFFF8, 0xFFFFFFFFFFF8, 0x1FFFFFF0000, 0x7FFFFFFFF8, + 0x47FFFFFFFF0010, 0x7FFFFFFFFFFF8, 0x1400001E, 0xFFFFFFBFFFF, + 0xFFFF01FFBFFFBD7F, 0x23EDFDFFFFF99FE0, 0x3E0010000, 0x1FFFFFFFFFFFFF, + 0x780, 0xFFFFFFFFFFFF, 0xB0, 0x7FFFFFFFFFFF, 0xF000000, 0x10, + 0x7FFFFFFFFFF, 0x7FFFFFF, 0xFFFFFFFFFFF, 0xFFFFFFFF00000000, + 0x80000000FFFFFFFF, 0x407FFFFFFFFF801, 0xFFFFFFFFF0010000, 0x200003CF, + 0x1FFFFFFFFFFFFFF, 0x7FFFFFFFFDFF, 0xFFFC000000000001, 0xFFFF, + 0x1FFFFFFFFFB7F, 0xFFFFFDBF00000040, 0x10003FF, 0x7FFFF00000000, + 0x3FFFFFF, 0xF, 0x7F, 0x3FFFFFFF0000, 0xE0FFFFF80000000F, 0x1001F, + 0xFFF80000, 0x300000000, 0x3FFFFFFFFFFFF, 0xFFFF000000000000, + 0xFFFFFFFFFFFFFFF, 0x1FFF07FFFFFFFFFF, 0x3FF01FF, 0xFFFFFFFFFFDFFFFF, + 0xEBFFDE64DFFFFFFF, 0xFFFFFFFFFFFFFFEF, 0x7BFFFFFFDFDFE7BF, + 0xFFFFFFFFFFFDFC5F, 0xFFFFFF3FFFFFFFFF, 0xF7FFFFFFF7FFFFFD, + 0xFFDFFFFFFFDFFFFF, 0xFFFF7FFFFFFF7FFF, 0xFFFFFDFFFFFFFDFF, 0xFF7, 0x1F, + 0xAF7FE96FFFFFFEF, 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x7FFFFF, + 0xFFFF0003FFFFFFFF, 0x1FFFFFFFF, 0x3FFFFFFF, + ], +}; + +pub const LETTER_NUMBER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1C00000000000, 0xFFFFFFFF00000000, 0x1E7, 0x70003FE00000080, + 0xFFC000000000, + ], + tree3_level1: &[ + 0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x1FFFFFFFFFFFFF, 0x402, 0x3E0000, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFF, + ], +}; + +pub const LINE_SEPARATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x10000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const LOWERCASE_LETTER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE00000000, 0x20000000000000, 0xFF7FFFFF80000000, + 0x55AAAAAAAAAAAAAA, 0xD4AAAAAAAAAAAB55, 0xE6512D2A4E243129, + 0xAA29AAAAB5555240, 0x93FAAAAAAAAAAAAA, 0xFFFFFFFFFFFFAA85, + 0xFFFFFFEFFFFF, 0, 0, 0x388A000000000000, 0xFFFFF00000010000, + 0x192FAAAAAAE37FFF, 0xFFFF000000000000, 0xAAAAAAAAFFFFFFFF, + 0xAAAAAAAAAAAAA802, 0xAAAAAAAAAAAAD554, 0xAAAAAAAAAAAA, + 0xFFFFFFFF00000000, 0x1FF, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 5, 6, 0, 7, 7, 8, 7, 9, 10, 11, 12, 0, 0, 0, + 0, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, 7, + 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 0, 22, 23, 24, 25, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 16, 26, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, + ], + tree2_level2: &[ + 0, 0xE7FFFFFFFFFF0000, 0x3F00000000000000, 0x1FF, 0xFFFFFFFFFFF, + 0xFEFFF80000000000, 0x7FFFFFF, 0xAAAAAAAAAAAAAAAA, 0xAAAAAAAABFEAAAAA, + 0xFF00FF003F00FF, 0x3FFF00FF00FF003F, 0x40DF00FF00FF00FF, + 0xDC00FF00CF00DC, 0x321080000008C400, 0x43C0, 0x10, 0xFFFF000000000000, + 0xFDA15627FFFFFFF, 0x8501AAAAAAAAA, 0x20BFFFFFFFFF, 0x2AAAAAAAAAAA, + 0xAAAAAAA, 0xAAABAAA800000000, 0x95FEAAAAAAAAAAAA, 0x2A082AAAABA50AA, + 0x400000000000000, 0xFFFF003F07FFFFFF, 0xFFFFFFFFFFFFFFFF, 0xF8007F, + 0x7FFFFFE, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFF0000000000, 0xFFFF, 0xFFFFFFFFF000000, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF, 0xFFFFFFFF00000000, 0xFFFFFFC000000, 0xFFFFDFC000, + 0xEBC000000FFFFFFC, 0xFFFFFC000000FFEF, 0xFFFFFFC000000F, 0xFFFFFFC0000, + 0xFC000000FFFFFFC0, 0xFFFFC000000FFFFF, 0xFFFFFFC000000FF, 0xFFFFFFC00000, + 0x3FFFFFFC00, 0xF0000003F7FFFFFC, 0xFFC000000FDFFFFF, 0xFFFF0000003F7FFF, + 0xFFFFFC000000FDFF, 0xBF7, 0xFFFFFFFC00000000, 0xF, + ], +}; + +pub const MARK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0, + 0, 0, 0, 0x3F8, 0, 0, 0, 0xBFFFFFFFFFFE0000, 0xB6, 0x7FF0000, + 0x10000FFFFF800, 0, 0x3D9F9FC00000, 0xFFFF000000020000, 0x7FF, + 0x1FFC000000000, 0x200FF80000000000, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 6, 8, 6, 9, 6, 10, 11, 12, 13, 14, 6, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 30, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 31, 32, 33, 34, 35, + 2, 36, 2, 37, 2, 2, 2, 38, 39, 40, 2, 41, 42, 43, 44, 45, 2, 2, 46, 2, 2, + 2, 47, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 48, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 49, 2, 50, 2, 51, 2, 2, 2, 2, 2, 2, 2, + 2, 52, 2, 53, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 54, 55, 56, 2, 2, 2, 2, 57, 2, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 2, + 2, 2, 68, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 69, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 70, 2, 2, 2, 2, 2, 2, 2, + ], + tree2_level2: &[ + 0x3EEFFBC00000, 0xE000000, 0, 0xFFFFFFFBFFF80000, 0xDC0000000000000F, + 0xC00FEFFFF, 0xD00000000000000E, 0x4000000C0080399F, 0x23000000023987, + 0xFC00000C00003BBF, 0xC00C0399F, 0xC000000000000004, 0x803DC7, + 0xC00000000000001F, 0xC00603DDF, 0xD80000000000000F, 0xC00803DDF, 0xC, + 0xC0000FF5F8400, 0x7F2000000000000, 0x7F80, 0x1BF2000000000000, 0x3F00, + 0xC2A0000003000000, 0xFFFE000000000000, 0x1FFFFFFFFEFFE0DF, 0x40, + 0x7FFFF80000000000, 0x1E3F9DC3C00000, 0x3C00BFFC, 0xE0000000, + 0x1C0000001C0000, 0xC0000000C0000, 0xFFF0000000000000, 0x200FFFFF, 0x3800, + 0x20000000060, 0xFFF0FFF00000000, 0xF800000, 0x9FFFFFFF7FE00000, + 0x7FFF000000000000, 0xFFF000000000001F, 0xFF8000000001F, 0x3FFE00000007, + 0xFFFC000000000, 0xFFFFF000000000, 0x39C21FFFFF70000, 0xFBFFFFFFFFFFFFFF, + 0x1FFFFFFFF0000, 0x3800000000000, 0x8000000000000000, 0xFFFFFFFF00000000, + 0xFC0000000000, 0x6000000, 0x3FF7800000000000, 0xC0000000, + 0x3000000000000, 0xF800000844, 0xFFF0000000000003, 0x8003FFFF0000003F, + 0x3FC000000000, 0xFFF80, 0xFFF800000000000F, 0x2000000001, + 0x7FFE0000000000, 0x3800000000003008, 0xC19D000000000000, + 0x60F80000000002, 0x37F800000000, 0x40000000, 0xFFFF0000FFFF, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 8, 9, 10, 0, 11, 12, 13, 14, 15, + 0, 0, 16, 17, 18, 0, 0, 19, 20, 21, 22, 0, 0, 23, 24, 21, 25, 26, 0, 27, + 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 29, 30, 31, 0, 0, 0, 0, 0, 32, 0, 33, 0, + 34, 35, 36, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, 39, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 44, 0, 0, 45, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 46, 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 52, 52, + 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2000000000000000, 0x100000000, 0x7C0000000000000, 0x870000000000F06E, + 0x6000000000, 0xF000000000, 0x1FFC0, 0xFF00000000000007, + 0x800000000000007F, 0x7FF000000000007, 0x1FFF8000000007, 0x8000000000060, + 0xFFF8000000000007, 0x1E01, 0x40FFF00000000000, 0x7FF80000000, + 0xD80000000000000F, 0x1F1FCC0080399F, 0xFFE0000000000000, 0x4000007F, + 0xFFFF000000000000, 0xF, 0xFF3F800000000000, 0x30000001, 0x1, + 0xFFF80000000000, 0xFFFE0000000, 0x7FFF00000000000, 0x7BF80000000007FE, + 0xFFE0080, 0x3FFFC00, 0xFF7F800000000000, 0x7FFEFFFFFC0000, + 0xB47E000000000000, 0xBF, 0xFB7C00, 0x78000000000000, 0x1F000000000000, + 0x7F000000000000, 0x7FFFFFFFFFFE0000, 0x78000, 0x60000000, + 0xF807E3E000000000, 0x3C0000000FE7, 0x1C, 0xF87FFFFFFFFFFFFF, + 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F, 0x7F0000, 0x7F0, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const MATH_SYMBOL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x7000080000000000, 0x5000000000000000, 0x2100000000000, 0x80000000800000, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x40000000000000, 0, 0, 0, 0, 0, 0, 0, 0, + 0x1C0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, + 3, 4, 5, 6, 7, 7, 7, 7, 8, 9, 10, 11, 0, 0, 0, 0, 0, 0, 12, 13, 0, 14, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 0, 7, 7, 16, 17, 7, 7, 7, 7, 18, 19, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0, 22, 23, 0, 24, + ], + tree2_level2: &[ + 0, 0x1C00000000040010, 0x1C00, 0x1000000, 0x81F, 0x40490C1F0000, + 0xFFF000000014C000, 0xFFFFFFFFFFFFFFFF, 0x300000000, 0x1000000000000000, + 0xFFFFFF8000000, 0x3F0000000, 0x80000000000000, 0xFF00000000000002, + 0x800000000000, 0xFFFF003FFFFFFF9F, 0xFFFFFFFFFE000007, + 0xCFFFFFFFF0FFFFFF, 0xFFFF000000000000, 0x1F9F, 0x20000000000, + 0x7400000000, 0x70000800, 0x50000000, 0x1E0400000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x800000008000002, 0x20000000200000, 0x800000008000, 0x20000000200, + 0x8, 0x3000000000000, + ], +}; + +pub const MODIFIER_LETTER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFFFF000000000000, 0x501F0003FFC3, 0, + 0x410000000000000, 0, 0, 0, 0, 0, 0, 0, 0x2000000, 0, 0, 0, 0x1, 0, + 0x6000000000, 0, 0, 0, 0x430000000000000, + ], + tree2_level1: &[ + 0, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 7, + 1, 1, 1, 1, 1, 1, 8, 1, 1, 9, 10, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 12, + 13, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 14, + 1, 1, 1, 15, 1, 1, 15, 1, 1, 1, 1, 1, 1, 1, 16, 1, 17, 18, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 19, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 20, 21, 22, 1, 23, 24, 25, 26, + 1, 1, 1, 1, 1, 1, 1, 27, 1, 24, 1, 28, 1, 29, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 24, 30, 1, + ], + tree2_level2: &[ + 0x11004000000, 0, 0x2000000000000, 0x40, 0x1000000000000000, 0x800000, + 0x8, 0x8000000000, 0x3F00000000000000, 0xFFFFF00000000000, + 0x10007FFFFFFFFFF, 0xFFFFFFFFF8000000, 0x8002000000000000, 0x1FFF0000, + 0x3000000000000000, 0x800000000000, 0x83E000000000020, 0x60000000, + 0x7000000000000000, 0x200000, 0x1000, 0x8000000000000000, 0x30000000, + 0xFF800000, 0x1000000000000, 0x100, 0x300000000000000, 0x4000008000, + 0x18000020000000, 0xF0000000, 0xC0000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2, 3, + ], + tree3_level3: &[ + 0, 0xF, 0xFFF80000, 0x300000000, + ], +}; + +pub const MODIFIER_SYMBOL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x140000000, 0x110810000000000, 0, 0, 0, 0, 0, 0, 0, 0, + 0xFFFFAFE0FFFC003C, 0, 0x20000000000000, 0x30, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 0, 11, + ], + tree2_level2: &[ + 0, 0xA000000000000000, 0x6000E000E000E003, 0x18000000, 0x3007FFFFF, 0x600, + 0x8000000, 0xFFFC000000000000, 0x3, 0x4000000000000000, 0x1, 0x800000000, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xF800000000000000, + ], +}; + +pub const NONSPACING_MARK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, 0, + 0, 0, 0, 0xF8, 0, 0, 0, 0xBFFFFFFFFFFE0000, 0xB6, 0x7FF0000, + 0x10000FFFFF800, 0, 0x3D9F9FC00000, 0xFFFF000000020000, 0x7FF, + 0x1FFC000000000, 0x200FF80000000000, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 10, 11, 12, 13, 14, 15, 16, 11, 17, 18, + 19, 2, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 32, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 34, 35, 36, + 37, 2, 38, 2, 39, 2, 2, 2, 40, 41, 42, 2, 43, 44, 45, 46, 47, 2, 2, 48, 2, + 2, 2, 49, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 50, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 51, 2, 52, 2, 53, 2, 2, 2, 2, 2, 2, + 2, 2, 54, 2, 55, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 56, 57, 58, 2, 2, 2, 2, 59, 2, 2, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 2, 2, 2, 69, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 70, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 71, 2, 2, 2, 2, 2, 2, 2, + ], + tree2_level2: &[ + 0x3EEFFBC00000, 0xE000000, 0, 0xFFFFFFFBFFF80000, 0x1400000000000007, + 0xC00FE21FE, 0x1000000000000002, 0x4000000C0000201E, 0x1000000000000006, + 0x23000000023986, 0xFC00000C000021BE, 0x9000000000000002, 0xC0040201E, + 0x4, 0x2001, 0xC000000000000011, 0xC00603DC1, 0xC00003040, + 0x1800000000000003, 0xC0000201E, 0x5C0400, 0x7F2000000000000, 0x7F80, + 0x1BF2000000000000, 0x3F00, 0x2A0000003000000, 0x7FFE000000000000, + 0x1FFFFFFFFEFFE0DF, 0x40, 0x66FDE00000000000, 0x1E0001C3000000, + 0x20002064, 0xE0000000, 0x1C0000001C0000, 0xC0000000C0000, + 0x3FB0000000000000, 0x200FFE40, 0x3800, 0x20000000060, 0xE04018700000000, + 0x9800000, 0x9FF81FE57F400000, 0x3FFF000000000000, 0x17D000000000000F, + 0xFF80000000004, 0x3B3C00000003, 0x3A34000000000, 0xCFF00000000000, + 0x31021FDFFF70000, 0xFBFFFFFFFFFFFFFF, 0x1FFE21FFF0000, 0x3800000000000, + 0x8000000000000000, 0xFFFFFFFF00000000, 0x3C0000000000, 0x6000000, + 0x3FF0800000000000, 0xC0000000, 0x3000000000000, 0x6000000844, + 0x8003FFFF00000030, 0x3FC000000000, 0x3FF80, 0x13C8000000000007, + 0x2000000000, 0x667E0000000000, 0x1000000000001008, 0xC19D000000000000, + 0x40300000000002, 0x212000000000, 0x40000000, 0xFFFF0000FFFF, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 8, 9, 10, 0, 11, 12, 13, 14, 15, + 0, 0, 16, 17, 18, 0, 0, 19, 20, 21, 22, 0, 0, 23, 24, 25, 26, 27, 0, 28, + 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 0, 0, 0, 0, 0, 33, 0, 34, 0, + 35, 36, 37, 0, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 40, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 44, 0, 0, 45, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 46, 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 52, 52, + 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x2000000000000000, 0x100000000, 0x7C0000000000000, 0x870000000000F06E, + 0x6000000000, 0xF000000000, 0x1FFC0, 0xFF00000000000002, + 0x800000000000007F, 0x678000000000003, 0x1FEF8000000007, 0x8000000000000, + 0x7FC0000000000003, 0x1E00, 0x40D3800000000000, 0x7F880000000, + 0x1800000000000003, 0x1F1FC000000001, 0xFF00000000000000, 0x4000005C, + 0x85F8000000000000, 0xD, 0xB03C000000000000, 0x30000001, + 0xA7F8000000000000, 0x1, 0xBF280000000000, 0xFBCE0000000, + 0x6FF800000000000, 0x79F80000000007FE, 0xE7E0080, 0x37FFC00, + 0xBF7F000000000000, 0x6DFCFFFFFC0000, 0xB47E000000000000, 0xBF, 0xA30000, + 0x18000000000000, 0x1F000000000000, 0x7F000000000000, 0x78000, 0x60000000, + 0xF800038000000000, 0x3C0000000FE7, 0x1C, 0xF87FFFFFFFFFFFFF, + 0x201FFFFFFFFFFF, 0xFFFEF8000010, 0x7DBF9FFFF7F, 0x7F0000, 0x7F0, + 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF, + ], +}; + +pub const NUMBER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x3FF000000000000, 0, 0x720C000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x3FF00000000, 0, 0x3FF000000000000, 0, + 0, 0, 0x3FF, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 1, 0, 2, 0, 1, 0, 1, 0, 3, 0, 4, 0, 5, 0, 1, 0, 6, 0, 1, 0, + 7, 0, 7, 8, 0, 0, 0, 0, 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 12, 7, 0, 0, 0, 0, 13, 0, 14, + 0, 0, 15, 0, 0, 7, 16, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 17, 9, 0, 0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 27, + 0, 28, 29, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 1, 0, 0, 0, 0, + 31, 0, 0, 7, 9, 0, 0, 32, 0, 7, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFC000000000, 0x3F0FFC000000000, 0xFCFFC000000000, 0x7FFC000000000, + 0x7F00FFC000000000, 0x1FFFFC07F000000, 0x3FF0000, 0xFFFFF00000000, 0x3FF, + 0x1FFFFE0000000000, 0x1C00000000000, 0x3FF03FF00000000, 0xFFC0, 0x7FF0000, + 0x3FF03FF, 0x3FF000000000000, 0x3F1000000000000, 0xFFFFFFFFFFFF0000, + 0x3E7, 0xFFFFFFFF00000000, 0xFFFFFFF, 0xFFFFFC0000000000, + 0xFFC0000000000000, 0xFFFFF, 0x2000000000000000, 0x70003FE00000080, + 0x3C0000, 0x3FF00000000, 0xFFFEFF00, 0xFFFE0000000003FF, 0x3F000000000000, + 0x3FF000003FF0000, + ], + tree3_level1: &[ + 0, 1, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 5, 6, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, + ], + tree3_level2: &[ + 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 4, 5, 6, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 11, 12, 0, 13, 14, 0, 15, 16, 17, 0, 18, + 19, 0, 0, 0, 0, 20, 21, 0, 0, 0, 0, 22, 0, 0, 23, 24, 0, 0, 0, 25, 0, 21, + 26, 0, 0, 27, 0, 0, 0, 21, 0, 0, 0, 0, 0, 28, 0, 28, 0, 0, 0, 0, 0, 28, 0, + 29, 30, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 0, 0, 0, 28, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 33, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 38, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFF80, 0x1FFFFFFFFFFFFFF, 0xC00, 0xFFFFFFE00000000, + 0xF00000000, 0x402, 0x3E0000, 0x3FF00000000, 0xFE000000FF000000, + 0xFF8000000000, 0xF800000000000000, 0xFC00000, 0x3000000000000000, + 0xFFFFFFFFFFFCFFFF, 0x60000000000001FF, 0xE0000000, 0xF80000000000, + 0xFF000000FF000000, 0xFE0000000000, 0xFC00000000000000, 0x3FF000000000000, + 0x7FFFFFFF00000000, 0x7FE0000000, 0x1E0000, 0xFFFFFFFC0000, + 0xFFC0000000000000, 0x1FFFFE03FF0000, 0x3FF0000, 0x3FF, 0xFFF000000000000, + 0x7FFFF00000000, 0x1FFFFFFF0000, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFF, + 0x3FBFF0000, 0x7FFFFF, 0xFFFFF00000000, 0x1FFFFFF00000000, + 0xFFFFFFFFFFFFC000, 0xFF80, 0xFFFE000000000000, 0x1EEFFFFFFFFFFF, 0x1FFF, + ], +}; + +pub const OPEN_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x10000000000, 0x800000008000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 8, 0, 0, 0, 0, 0, 0, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 11, 12, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 15, 16, 0, 0, 17, 18, 0, 0, + ], + tree2_level2: &[ + 0, 0x1400000000000000, 0x8000000, 0x44000000, 0x2000000000000020, 0x2000, + 0x20000000500, 0x15550000000000, 0x554000000020, 0xAAAAA8, + 0x1000000005000000, 0x15400000000, 0x4, 0x25515500, 0x8000000000000000, + 0xAAA0000000800000, 0x2A00008A, 0x800000000000100, 0x488000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const OTHER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0xFFFFFFFF, 0x8000000000000000, 0x2000FFFFFFFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0x300000000000000, 0x40000280F, 0, 0, 0, 0, 0, 0x1000000000000, + 0x1800000, 0x11800, 0xFFE078000000FF00, 0x3000003F, 0, 0, 0x20000000, + 0xC000, 0x1800, 0xFFFC000000000000, 0x1800000000000000, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 4, 27, 28, 29, 4, 4, 4, 30, 4, 4, 4, 4, 4, 31, + 32, 33, 34, 35, 36, 37, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 38, 39, 40, 41, 4, + 42, 43, 39, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 4, 54, 4, 55, 56, 57, + 58, 59, 4, 4, 4, 60, 4, 4, 4, 4, 61, 62, 63, 64, 65, 66, 67, 68, 4, 4, 69, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 70, 71, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 72, 73, 74, 75, 76, 4, 77, 78, + 79, 80, 81, 4, 82, 83, 84, 4, 4, 4, 85, 4, 86, 87, 4, 88, 4, 89, 90, 76, + 4, 4, 91, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 45, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 92, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 93, 94, 4, 4, 4, 4, 95, 4, 4, 96, 4, 4, 97, + 98, 99, 96, 4, 100, 4, 101, 4, 102, 103, 104, 4, 105, 106, 107, 4, 108, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 90, + 109, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 53, 53, 53, 53, 53, 53, 53, 4, 4, 4, 4, 4, 110, 4, 111, 112, 113, 4, 114, + 4, 4, 4, 4, 4, 115, 116, 117, 36, 118, 4, 119, 86, 4, 91, 120, + ], + tree2_level2: &[ + 0x8000C00000000000, 0xFFFFF800B0000000, 0xC0200000FFFFFFFF, 0x40007FFFF, + 0, 0xC3A020000066010, 0x800000304F7F8660, 0x2C92020000067811, + 0xFF80003FA1FDC678, 0xC12020000044011, 0x1FC0030FFFEC440, + 0xC12020000066011, 0xFF0000304F3FC660, 0x3C0038E729C23813, + 0xF800003FFF7EC238, 0x1C00020000022000, 0xFF0030F89FC220, + 0xC10020000022000, 0xFFF90030BF9FC220, 0x22010, 0x30000F0220, + 0xD004000003800013, 0xFFE3003F00A07B80, 0x7800000000000001, + 0xFFFFFFFFF0000000, 0xC4001351010FDA69, 0xFFFFFFFF0C00C0A0, + 0x1E00000000100, 0x2000000001000000, 0xFFFFFFFFF8002000, 0xDF40, + 0xC280C200, 0x80C200000000C200, 0x8000C2, 0xC20000, 0xE000000018000000, + 0xFC000000, 0xC0C0000000000000, 0xE0000000, 0xFE00000000000000, + 0xFF800000FFE02000, 0xFFF22000FFF00000, 0xFC00FC00C0000000, 0xFC00C000, + 0xF80000000000, 0xFFC0000000000000, 0xF000F00080000000, + 0xFFE0C0000000000E, 0xF00000000000, 0x3800FC00, 0x30000000, + 0x6000000080000000, 0x8000C000FC00FC00, 0xFFFFFFFFFFFFFFFF, + 0xE00000000000F000, 0xFF0000000000000, 0x700000000000000, 0x1C00, + 0x180000000000FE00, 0xFC0000000000FF00, 0x400000000000000, 0xC0C00000, + 0xC00000005500C0C0, 0x20000000000000, 0x8023000010300020, 0x7C000000F800, + 0xCFFFF00000000, 0xE0008000, 0xFFFE00000000FFFF, 0xF000, + 0xFFFFFF8000000000, 0xFFFFF800, 0x30000000000000, 0xC00000, + 0x8000000000000200, 0x800000000000, 0x80000000, 0x1F0000000000000, + 0xDF4000000000, 0x7FFE7F0000000000, 0x80808080FF800000, 0x80808080, + 0xFFFFFFFFFFFF8000, 0x4000000, 0xFFF0000000000000, 0xF000FFFFFFC00000, + 0x1, 0x1800000, 0x100000000001F, 0xF800000000008000, 0xFFF000000000, + 0x8000000000000000, 0xFFFF000000000000, 0xE000, 0xFF80, + 0xFFFFF00000000000, 0xFF00000000000000, 0xFC00000000000000, + 0x7FFFFFFFFFFFFF, 0xFC00F00000000000, 0xFC003FC0, 0xE00000007FF00000, + 0x800000003C004000, 0xFF80000000000000, 0xC00C000, 0xFF80000007FFFFF8, + 0x8080FF818181, 0xFFC000000000, 0xFC00C00000000000, 0xF000000000000780, + 0xC00000000000, 0xFFFFFFFFFC000000, 0xA08000001F07FF80, 0x24, 0x7FFFC, + 0xFFFF, 0x30000, 0xC000FFFFFFFFFF00, 0x20F08000080000, 0xE000000000000000, + 0xCFFF8080E3030303, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 12, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 13, 14, 15, 7, 16, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 18, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 2, 5, 6, 7, 7, 8, 9, 10, 11, 12, 13, 2, 2, 14, 15, 16, 17, + 7, 7, 2, 2, 2, 2, 18, 19, 7, 7, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 7, 2, 34, 35, 36, 37, 7, 7, 7, 7, 38, 7, 7, 16, 39, 7, 7, + 2, 40, 41, 42, 43, 44, 2, 45, 46, 7, 47, 48, 49, 50, 7, 7, 2, 51, 2, 52, + 7, 7, 53, 54, 2, 55, 56, 57, 58, 7, 7, 7, 59, 7, 60, 61, 7, 7, 7, 7, 2, + 62, 63, 64, 7, 7, 7, 7, 65, 66, 67, 7, 68, 69, 70, 7, 7, 7, 7, 71, 7, 7, + 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 39, 7, 2, 72, 2, 2, 2, 73, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 74, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 75, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, + 2, 64, 76, 7, 77, 2, 78, 79, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 80, 7, 2, + 81, 82, 83, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 84, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 35, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 85, 86, 2, 2, 2, 2, 2, 59, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 2, 87, 88, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 2, 2, 2, 89, 90, 91, 2, 92, 2, 93, 7, 94, 2, 95, 7, 7, 2, 96, 97, 98, 99, + 100, 2, 2, 2, 2, 101, 2, 2, 2, 2, 102, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 103, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 104, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 2, 2, 2, 105, 2, 106, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 107, + 108, 7, 7, 7, 7, 7, 109, 110, 111, 112, 7, 7, 7, 7, 113, 2, 114, 115, 116, + 113, 117, 118, 119, 120, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 121, 2, 122, 2, 123, 124, 125, 126, 7, 127, 128, 129, 130, 7, 131, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 132, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 108, 2, 2, 2, 133, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 134, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 135, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 54, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 2, 2, 2, 136, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + ], + tree3_level3: &[ + 0x4800008000001000, 0xFFFFFFFFC000C000, 0, 0xF800000000000000, + 0x70000000000078, 0xFFFFFFFEF0008000, 0xC00000000000FFFF, + 0xFFFFFFFFFFFFFFFF, 0xE0000000, 0xF0000000FFFE0000, 0x1FF000000000, + 0xF80000000000F800, 0x40000000, 0xFFFFFFFFFFC000F0, 0xFC00C0000000, + 0xF000000000F00000, 0xFF0000000000, 0xFFFF7FF000000000, + 0xFF80000000000000, 0xFFFFFF00FFC00000, 0x6E400000000002C0, 0x400000, + 0xFFFF007F80000000, 0x7C80000FFFFFFFF, 0x7C00000070000000, + 0xF00000000000000, 0x30000, 0x78C0000001100F90, 0xFE00FE00, + 0xFFFFFFFF00000000, 0xFF80078000000000, 0x1C0000000000000, + 0xF8000000C00000, 0xFFFF01FFE1FC0000, 0xFFFFFFFFFFFFFE00, + 0xFFF8000000000000, 0x3F8000000000000, 0xFC00FF0000000000, + 0x80000000FFFFFFFF, 0xFFFFFFFFFC000000, 0x7FFF00000003C000, + 0x2000000000000000, 0xFC00FE000000FFFC, 0x20000000000000, + 0xFF8000000000FF80, 0xFFE000010000C000, 0x8000000000040000, + 0xFC0040004280, 0xFC00F80000000000, 0x412020000066010, 0xFFE0E0301F7EC660, + 0xFFFFFFFF94000000, 0xFFFFFFFFFC00FF00, 0xC0000000000000, + 0xFFFFFFFFC0000000, 0xFFFFE000FC00FFE0, 0xFF00000000000000, + 0xFFFFFFFFFFFFFC00, 0xF00018000000, 0xF000000000000000, 0xFFFFFFFF, + 0x7FF8000000000000, 0xFF00, 0xFFFFFFF800000030, 0xFE00000000000000, + 0x80000000000200, 0xE0000000FFC0, 0xFF80010000030000, 0x4B80000000000480, + 0x240FC00FF00, 0xFFFFFC00FE048000, 0xFE000000FFFFFFFF, 0xFFE0800000000000, + 0xFFFFFFFFFFFFFFF0, 0xFFFF800000000000, 0xFFFFFFFFFFFFFF80, + 0xFFFF3C0080000000, 0xFFC0C0000000FFFF, 0x1F0000040400FFC0, + 0xFFFFFFFFFFFF0000, 0xFFFFFFFFF8000000, 0x800000000000FFE0, + 0xFFFFFFFF00007FFF, 0xFFFFFFFCFFFFFFFF, 0xFFFC000000000000, + 0xFFFFFFFF80000000, 0xFFFFFFFFFFFF, 0xE000F80000000000, + 0xFFFFFFFF0C00FE00, 0xFFC0000000000000, 0x18000000000, 0x7F8000000000000, + 0xFFFFFE0000000000, 0xFFFFFFFFFFFFFFC0, 0xFFF00000FFFFFFFF, + 0xFE000000FF800000, 0x200000, 0x1400219B20000000, 0x10, + 0x8400000020201840, 0x203A0, 0xC000000000, 0x3000, 0xFFFF000107FFF000, + 0xFFFFF82406000080, 0xFFFFFFFFFF800060, 0xFFFFFFFF3C00F800, + 0x1FFFFFFFFFFFF, 0xFFE0000000000000, 0xF508016900000010, + 0xA10808695569157B, 0xF0000411F0000400, 0xFFFCFFFFFFFFFFFF, + 0xF00000000000, 0x18000FFF00000, 0xFFC0000000010001, 0xE000, + 0xFFFFE00000000000, 0x3FFFFFFFFF, 0xF00000000000FFF8, 0xFFFFFFC0FFFCFE00, + 0xFC00E000FFE00000, 0xFFF0000000000000, 0xFFFFFFFFFE000000, 0xF000, + 0xFC00FF00, 0xFFFFC0000000FF00, 0x800000000000F000, 0xB86000000000000, + 0xFC00FFF800000000, 0xFFF8, 0xFFFFC000FFFFFFFF, 0xFFFFFFFFFF800000, + 0xC0000000, 0xFFFC00000000, 0xFFFFFFFE00000000, 0xFFFF000000000000, + ], +}; + +pub const OTHER_LETTER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x400040000000000, 0, 0, 0, 0x800000000000000, 0xF, 0, 0, 0x100000, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x787FFFFFF0000, 0xFFFFFFFF00000000, + 0xFFFEC000000007FE, 0xFFFFFFFFFFFFFFFF, 0x9C00C000002FFFFF, + 0xFFFFFFFD0000, 0xFFFFFFFFFFFFE000, 0x2003FFFFFFFFF, 0x7FFFFFFFC00, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 3, 31, 32, 33, 3, 34, 34, 34, 34, + 34, 35, 36, 37, 38, 39, 40, 3, 41, 34, 34, 34, 34, 34, 34, 34, 34, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 3, 3, 59, 60, + 61, 62, 63, 64, 3, 65, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 66, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 67, 68, + 69, 70, 3, 3, 3, 3, 3, 3, 3, 3, 71, 41, 72, 73, 74, 34, 75, 67, 3, 3, 3, + 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 52, 3, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 76, 77, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 78, 79, 34, 34, 34, 34, 80, 81, 49, 62, 3, 3, 82, 83, 84, 47, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 3, 3, 96, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 97, 98, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, + 99, 34, 100, 101, 102, 103, 104, 34, 34, 34, 34, 105, 106, 107, 108, 3, + 109, 34, 110, 3, 111, 112, 113, + ], + tree2_level2: &[ + 0x3FFFFF, 0x7FF01FFFFFF, 0x3FDFFFFF00000000, 0, 0x23FFFFFFFFFFFFF0, + 0xFFFC0003FF010000, 0x23C5FDFFFFF99FE1, 0x10030003B0004000, + 0x36DFDFFFFF987E0, 0x1C00005E000000, 0x23EDFDFFFFFBBFE0, + 0x200000300010000, 0x23EDFDFFFFF99FE0, 0x20003B0000000, 0x3FFC718D63DC7E8, + 0x10000, 0x23FFFDFFFFFDDFE0, 0x307000000, 0x23EFFDFFFFFDDFE1, + 0x6000340000000, 0x27FFFFFFFFFDDFE0, 0xFC00000380704000, + 0x2FFBFFFFFC7FFFE0, 0x7F, 0xDFFFFFFFFFFFE, 0x3F, 0x200DECAEFEF02596, + 0xF000001F, 0x1, 0x1FFFFFFFFEFF, 0x1F00, 0x800007FFFFFFFFFF, + 0xFFE1C0623C3F0000, 0x4003, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF3D7F3DFF, + 0x7F3DFFFFFFFF3DFF, 0xFFFFFFFFFF7FFF3D, 0xFFFFFFFFFF3DFFFF, 0x7FFFFFF, + 0xFFFF, 0xFFFFFFFFFFFFFFFE, 0xFFFF9FFFFFFFFFFF, 0xFFFFFFFF07FFFFFE, + 0x1FE07FFFFFFFFFF, 0x3FFFF0003DFFF, 0x1DFFF0003FFFF, 0xFFFFFFFFFFFFF, + 0x10000000, 0xFFFFFFFF00000000, 0x1FFFFFFFFFFFFF7, 0xFFFF05FFFFFFFF9F, + 0x3FFFFFFFFFFFFF, 0x7FFFFFFF, 0x1F3FFFFFFF0000, 0xFFFF0FFFFFFFFFFF, 0x3FF, + 0xFFFFFFFF007FFFFF, 0x1FFFFF, 0xFFFFFFFFFFFE0, 0xFE0, 0xFC00C001FFFFFFF8, + 0x3FFFFFFFFF, 0xFFFFFFFFF, 0xFFFFFFFC00E000, 0x63DE0000000000, + 0x1E0000000000000, 0xFFFF000000000000, 0xFFFFFFFFFF, 0x7F7F7F7F007FFFFF, + 0x7F7F7F7F, 0x1000000000000040, 0xFFFFFFFE807FFFFF, 0x87FFFFFFFFFFFFFF, + 0xFFFEFFFFFFFFFFE0, 0x7FFFFFF00007FFF, 0xFFFFFFFFFFFF, 0xFFFFFFFFFFDFFFFF, + 0x1FFF, 0xFFFFFFFFFF0000, 0xC00FFFF0FFF, 0x400000000000, 0x8000, + 0xF880000000000000, 0x7FFFFF7BB, 0xFFFFFFFFFFFFC, 0x68FC000000000000, + 0xFFFF003FFFFFFC00, 0x1FFFFFFF0000007F, 0x7FFFFFFFFFFF0, + 0x7C00FF9F00000000, 0x1FFFFFFFFFF, 0xC47EFFFF00000FF7, 0x3E62FFFFFFFFFFFF, + 0x407FF18000005, 0x7F7F007E7E7E, 0x7FFFFFFFF, 0xFFFF000FFFFFFFFF, + 0xFFFFFFFFFFFF87F, 0xFFFF3FFFFFFFFFFF, 0x3FFFFFF, 0x5F7FFDFFA0000000, + 0xFFFFFFFFFFFFFFDB, 0x3FFFFFFFFFFFF, 0xFFFFFFFFFFF80000, + 0x3FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFCFFFF, + 0xFFF0000000000FF, 0xFFDF000000000000, 0x1FFFFFFFFFFFFFFF, + 0xFFFEFFC000000000, 0x7FFFFFFF3FFFFFFF, 0x1CFCFCFC, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 5, 10, 5, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 11, 12, 13, 7, 14, 15, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10, 4, 11, 12, 4, 13, 14, 4, + 4, 2, 2, 2, 2, 15, 16, 4, 4, 17, 18, 19, 20, 21, 4, 22, 4, 23, 24, 25, 26, + 27, 28, 29, 4, 2, 30, 4, 4, 14, 4, 4, 4, 4, 4, 4, 4, 31, 32, 4, 4, 33, 4, + 34, 35, 36, 37, 38, 39, 40, 4, 41, 19, 42, 43, 4, 4, 44, 45, 46, 47, 4, 4, + 48, 49, 46, 50, 51, 4, 52, 4, 4, 4, 53, 4, 4, 54, 4, 4, 4, 4, 55, 56, 57, + 58, 4, 4, 4, 4, 59, 60, 61, 4, 62, 63, 64, 4, 4, 4, 4, 65, 4, 4, 4, 4, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 66, 4, 4, 4, 2, 2, 2, 67, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 48, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 68, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 58, + 19, 4, 69, 46, 70, 61, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 71, 4, 4, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 72, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 73, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 2, 2, 2, 2, 19, 74, 2, 2, 2, 2, 2, 75, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 2, 76, 77, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 2, 2, 2, 78, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 79, 80, 81, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 82, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 44, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 83, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 84, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 12, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + ], + tree3_level3: &[ + 0xB7FFFF7FFFFFEFFF, 0x3FFF3FFF, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF, 0, + 0xFFFFFFFF1FFFFFFF, 0x1FFFF, 0xFFFFE000FFFFFFFF, 0x3FFFFFFFFF03FD, + 0xFFFFFFFF3FFFFFFF, 0xFF0F, 0xFFFFFFFFFFFF0000, 0x3FFFFFFF, + 0xFFFF00FFFFFFFFFF, 0xFFFFFFFFF, 0x7FFFFFFFFFFFFF, 0xFF003FFFFF, + 0x91BFFFFFFFFFFD3F, 0x7FFFFF003FFFFF, 0x7FFFFFFF, 0x37FFFF00000000, + 0x3FFFFFF003FFFFF, 0xC0FFFFFFFFFFFFFF, 0x3FFFFFFEEF0001, + 0x1FFFFFFF00000000, 0x1FFFFFFF, 0x1FFFFFFEFF, 0x3FFFFFFFFFFFFF, + 0x7FFFF003FFFFF, 0x3FFFF, 0x1FF, 0xFFFF00801FFFFFFF, 0x3F, + 0xFFFFFFFFFFFFF8, 0xFFFFFFFFFFF8, 0x1FFFFFF0000, 0x7FFFFFFFF8, + 0x47FFFFFFFF0010, 0x7FFFFFFFFFFF8, 0x1400001E, 0xFFFFFFBFFFF, + 0xFFFF01FFBFFFBD7F, 0x23EDFDFFFFF99FE0, 0x3E0010000, 0x1FFFFFFFFFFFFF, + 0x780, 0xFFFFFFFFFFFF, 0xB0, 0x7FFFFFFFFFFF, 0xF000000, 0x10, + 0x7FFFFFFFFFF, 0x7FFFFFF, 0xFFFFFFFFFFF, 0x8000000000000000, + 0x407FFFFFFFFF801, 0xFFFFFFFFF0010000, 0x200003CF, 0x1FFFFFFFFFFFFFF, + 0x7FFFFFFFFDFF, 0xFFFC000000000001, 0xFFFF, 0x1FFFFFFFFFB7F, + 0xFFFFFDBF00000040, 0x10003FF, 0x7FFFF00000000, 0x3FFFFFF, 0xF, 0x7F, + 0x3FFFFFFF0000, 0xE0FFFFF800000000, 0x1001F, 0x3FFFFFFFFFFFF, + 0x7FFFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFFFFFFFFFFFF, + 0x1FFF07FFFFFFFFFF, 0x3FF01FF, 0x1F, 0xAF7FE96FFFFFFEF, + 0x5EF7F796AA96EA84, 0xFFFFBEE0FFFFBFF, 0x7FFFFF, 0xFFFF0003FFFFFFFF, + 0x1FFFFFFFF, + ], +}; + +pub const OTHER_NUMBER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x720C000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 3, 0, 4, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, + 0, 0, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, + 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x3F0000000000000, 0xFC000000000000, 0x7000000000000, + 0x7F00000000000000, 0x1FF00007F000000, 0xFFC0000000000, + 0x1FFFFE0000000000, 0x3FF000000000000, 0x4000000, 0x3F1000000000000, + 0x3FF, 0xFFFF0000, 0x200, 0xFFFFFFFF00000000, 0xFFFFFFF, + 0xFFFFFC0000000000, 0xFFC0000000000000, 0xFFFFF, 0x2000000000000000, + 0x3C0000, 0x3FF00000000, 0xFFFEFF00, 0xFFFE0000000003FF, 0x3F000000000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 0, 10, 11, 0, 12, 13, 14, 0, 15, 16, + 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 18, 0, 0, 19, 20, 0, 0, 0, 21, 0, 0, 0, 0, + 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, + 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 28, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 31, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFF80, 0x1E0000000000000, 0xC00, 0xFFFFFFE00000000, + 0xF00000000, 0xFE000000FF000000, 0xFF8000000000, 0xF800000000000000, + 0xFC00000, 0x3000000000000000, 0xFFFFFFFFFFFCFFFF, 0x60000000000001FF, + 0xE0000000, 0xF80000000000, 0xFF000000FF000000, 0xFE0000000000, + 0xFC00000000000000, 0x7FFFFFFF00000000, 0x7FE0000000, 0x1E0000, + 0x3FFFFC0000, 0x1FFFFE00000000, 0xC00000000000000, 0x7FC0000000000, + 0x1FFFFC000000, 0x3F8000000, 0x7FFFFF, 0xFFFFF00000000, 0x1FFFFFF00000000, + 0xFF80, 0xFFFE000000000000, 0x1EEFFFFFFFFFFF, 0x1FFF, + ], +}; + +pub const OTHER_PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x8C00D4EE00000000, 0x10000001, 0x80C0008200000000, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0x4000000000000000, 0x80, 0, 0, 0, 0, 0, 0, 0xFC000000, 0x200, + 0x18000000000049, 0xC8003600, 0x3C0000000000, 0, 0x100000, 0x3FFF, 0, 0, + 0x380000000000000, + ], + tree2_level1: &[ + 0, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 2, 2, 2, 2, 2, 7, 2, 2, 2, 2, 8, 2, + 9, 2, 2, 10, 2, 11, 12, 2, 13, 2, 14, 2, 2, 2, 2, 2, 2, 2, 2, 2, 15, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 16, 2, 17, 18, 2, 2, 19, 20, 2, 2, 2, 2, 21, 2, + 2, 22, 2, 23, 2, 2, 24, 2, 25, 26, 27, 2, 28, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 29, 30, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 31, 2, 6, 2, 2, 32, 33, 2, 2, 2, 2, 2, 2, 34, 2, 2, 14, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 27, 2, 2, 2, 2, 35, 36, 2, 37, 2, 2, + 2, 2, 2, 38, 2, 39, 40, 41, 2, 42, 2, 43, 2, 44, 2, 2, 2, 45, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 46, 47, 2, 2, 48, 49, 2, 2, + ], + tree2_level2: &[ + 0x7FFF000000000000, 0x40000000, 0, 0x1003000000000, 0x2000000000000000, + 0x40000000000000, 0x1000000000000, 0x10, 0x10000000000000, 0xC008000, + 0x17FFF0, 0x20, 0x61F0000, 0xFC00, 0x800000000000000, 0x1FF00000000, + 0x600000000000, 0x380000000000, 0x60000000000000, 0x7700000, 0x7BF, 0x30, + 0xC0000000, 0x3F7F00000000, 0x1FC000000, 0xF000000000000000, + 0xF800000000000000, 0xC000000000000000, 0x800FF, 0x79FF00FF00C00000, + 0x7FEBFF8E, 0xDE00000000000000, 0xF3FF7C00CB7FC9C3, 0x7FFA, + 0x200000000000000E, 0xE000, 0x4008000000000000, 0xFC000000000000, + 0xF0000000000000, 0x170000000000C000, 0xC00000000000, 0x80000000, + 0xC0003FFE, 0xF0000000, 0x30000C0000000, 0x80000000000, 0x10000027F0000, + 0xD0380F71E60, 0x100000018C00D4EE, 0x3200000000, + ], + tree3_level1: &[ + 0, 1, 2, 3, 3, 3, 4, 3, 3, 3, 3, 5, 3, 6, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, + ], + tree3_level2: &[ + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 6, 0, 0, 0, 0, 7, 0, 8, 9, 0, 10, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 12, 13, 14, 0, 15, 0, 16, + 17, 0, 18, 0, 0, 0, 0, 0, 0, 19, 0, 20, 0, 0, 0, 21, 0, 22, 0, 0, 23, 0, + 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 25, 26, 27, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 31, 0, 32, 33, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x7, 0x80000000, 0x10000, 0x800000000000, 0x800000, 0x8000000080000000, + 0x8000000001FF0000, 0x7F000000000000, 0xFE00000000000000, 0x1E000000, + 0x3E00000, 0x3F80, 0xD800000000000000, 0x3, 0x3000000000000F, 0xE80021E0, + 0x3F00000000000000, 0x20000000000, 0x2800F800, 0x40, 0xFFFFFE, + 0x1FFF0000000E, 0x7000000000000000, 0x800000000000000, 0x8000000000000000, + 0x7F, 0x7DC000000, 0x300000000003E, 0x180000000000000, 0x1F000000000000, + 0xC00000000000, 0x20000000000000, 0xF80000000000000, 0x10, 0x7800000, + 0xF80, 0xC0000000, + ], +}; + +pub const OTHER_SYMBOL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0x1424000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x4, + 0, 0, 0, 0x6000, 0, 0xC000, 0, 0, 0x6000020040000000, 0, 0, 0, + 0x40000000000000, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 3, 0, 4, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 6, 0, 7, 8, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 12, 0, + 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 15, 16, 17, 0, 0, 0, 0, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 26, 27, 28, 26, 29, 26, 26, 26, 30, 31, 0, 26, 26, 26, 26, 0, 0, 0, 0, 0, + 0, 0, 0, 32, 33, 34, 35, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 37, 38, 26, 26, + 26, 39, 40, 0, 0, 0, 0, 0, 41, 42, 43, 44, 45, 46, 26, 26, 26, 26, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 47, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, + 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 51, 0, 0, 0, 0, 0, 0, 0, 52, + ], + tree2_level2: &[ + 0, 0x400000000000000, 0x1000000000000, 0x5F8000000000000, + 0x8000000000000000, 0x200000000008000, 0x1500000FCE8000E, + 0xC000000000000000, 0x1E0DFBF, 0xC0000000, 0x3FF0000, 0x1, + 0xFFFFFFFFC0000000, 0x1FF007FE00000000, 0xC0042AFC0D0037B, 0xB400, + 0xFFFFBFB6F3E00C00, 0xFFFFFFFEB3FFF, 0xFFFFF9FCFFFFF0FF, + 0xEFFFFFFFFFFFFFFF, 0xFFF0000007FFFFFF, 0xFFFFFFFC0FFFFFFF, 0x7FFFFFFFFF, + 0x7FF, 0xFFFFFFFFF0000000, 0x3FFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, + 0xFF7FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFD, 0xFFFF7FFFFFFFFFFF, 0xFFFFFFFFFF, + 0xFFFFFFFFFFF00000, 0xFFFFFFFFFFFF, 0xFFCFFFFFFFFFE060, + 0xFFFFFFFFFF3FFFFF, 0x7FFFFFFFFFFFFDFF, 0x7E000000000, 0xFFFFFFFFFBFFFFFF, + 0xFFFFFFFFFFFFF, 0xFFF0000003FFFFF, 0xC0C00001000C0010, 0xFFC30000, + 0xFFFFFFFFF, 0xFFFFFC007FFFFFFF, 0xFFFFFFFF000100FF, 0x1FFFFFFFFFC00, + 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, 0x7F, 0x2C00F0000000000, + 0x380000000000000, 0x2000000000000000, 0x3000611000000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, 11, + 12, 13, 14, 15, 16, 11, 17, 0, 0, 11, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 19, 20, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 23, 11, 24, 25, 26, 23, 27, 28, 29, 30, 0, 0, 11, + 11, 11, 31, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 32, 11, 33, 11, + 34, 35, 36, 37, 0, 38, 39, 40, 41, 0, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFF80000000000000, 0xFE00000000000000, 0x10FFF73FF, + 0x1FFFFFFFFFFF0000, 0x180000000000000, 0x100, 0x8000000000000000, + 0xF000000000000000, 0x20, 0x10000000, 0xFFFFFFFFFFFFFFFF, + 0x3FFFFFFFFFFFFF, 0xFFFFFE7FFFFFFFFF, 0x1C1FFFFFFFFF, 0xFFFFC3FFFFFFF018, + 0x1FFFFFFFFFF, 0x23, 0x7FFFFF, 0x780000000000000, 0xFFDFE00000000000, + 0x6F, 0x100000000000, 0xFFFF0FFFFFFFFFFF, 0xFFFE7FFF000FFFFF, + 0x3FFFFFFFFEFFFE, 0xFFFFFFFFFFFF0000, 0x1FFFFFFFFFFF, 0xFFFFFFC000000000, + 0xFFFFFFFFFFF0007, 0x3F000301FF, 0x7FFFFFFFFFFFFFF, 0x3FF1FFF001FFFFF, + 0xFFFFFFFFFFFFF, 0x1FFFFFF, 0xFFFFFFFFFFFF0FFF, 0xFFFFFFFF03FF00FF, + 0x3FFFFFFF00FF, 0x7FFFFFFFFFFF0FFF, 0xF479FFFFFFFFFFFF, 0x3FF0007FFFFFFFF, + 0xFFFFFFFFFFFF0007, 0x3FFF00000000, + ], +}; + +pub const PARAGRAPH_SEPARATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x20000000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const PRIVATE_USE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFFFFFFFFFF, + ], + tree3_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF, + ], +}; + +pub const PUNCTUATION: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x8C00F7EE00000000, 0x28000000B8000001, 0x88C0088200000000, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0x4000000000000000, 0x80, 0, 0, 0, 0, 0, 0, 0xFC000000, + 0x4000000000000600, 0x18000000000049, 0xC8003600, 0x3C0000000000, 0, + 0x100000, 0x3FFF, 0, 0, 0x380000000000000, + ], + tree2_level1: &[ + 0, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 2, 2, 2, 2, 2, 7, 2, 2, 2, 2, 8, 2, + 9, 2, 2, 10, 2, 11, 12, 2, 13, 2, 14, 2, 2, 2, 2, 2, 2, 2, 2, 2, 15, 2, 2, + 16, 2, 2, 2, 2, 2, 2, 2, 2, 17, 18, 19, 20, 2, 2, 21, 22, 2, 2, 2, 2, 23, + 2, 2, 24, 2, 25, 2, 2, 26, 2, 27, 28, 29, 2, 30, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 31, 32, 33, 2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 35, 2, 36, 2, 2, 2, 2, 2, 2, 37, 38, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 39, 2, 6, 2, 2, 40, 41, 2, 2, 2, 2, 2, 2, 42, + 2, 43, 14, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 29, 2, 2, 2, 2, 44, 45, + 2, 46, 2, 2, 2, 2, 2, 47, 2, 48, 49, 50, 2, 51, 2, 52, 2, 53, 2, 2, 2, 54, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 29, 2, 2, 2, 55, 56, 2, 2, 57, 58, 2, 2, + ], + tree2_level2: &[ + 0x7FFF000000000000, 0x40000000, 0, 0x1003000000000, 0x2000000000000000, + 0x40000000000000, 0x1000000000000, 0x10, 0x10000000000000, 0xC008000, + 0x3C0000000017FFF0, 0x20, 0x61F0000, 0xFC00, 0x800000000000000, + 0x1FF00000000, 0x1, 0x600000000000, 0x18000000, 0x380000000000, + 0x60000000000000, 0x7700000, 0x7FF, 0x30, 0xC0000000, 0x3F7F00000000, + 0x1FC000000, 0xF000000000000000, 0xF800000000000000, 0xC000000000000000, + 0x800FF, 0xFFFF00FFFFFF0000, 0x600000007FFBFFEF, 0x6000, 0x60000000F00, + 0x3FFF0000000000, 0xFFC000000060, 0x1FFFFF8, 0x300000000F000000, + 0xDE00000000000000, 0xFFFF7FFFFFFFFFFF, 0x7FFF, 0x20010000FFF3FF0E, + 0x100000000, 0xE000, 0x4008000000000000, 0xFC000000000000, + 0xF0000000000000, 0x170000000000C000, 0xC00000000000, 0x80000000, + 0xC0003FFE, 0xF0000000, 0x30000C0000000, 0x80000000000, + 0xFFFF000003FF0000, 0xD0BFFF7FFFF, 0xB80000018C00F7EE, 0x3FA8000000, + ], + tree3_level1: &[ + 0, 1, 2, 3, 3, 3, 4, 3, 3, 3, 3, 5, 3, 6, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, + ], + tree3_level2: &[ + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 6, 0, 0, 0, 0, 7, 0, 8, 9, 0, 10, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 12, 13, 14, 0, 15, 0, 16, + 17, 0, 18, 0, 0, 0, 0, 0, 0, 19, 0, 20, 0, 0, 0, 21, 0, 22, 0, 0, 23, 0, + 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 25, 26, 27, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 31, 0, 32, 33, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x7, 0x80000000, 0x10000, 0x800000000000, 0x800000, 0x8000000080000000, + 0x8000000001FF0000, 0x7F000000000000, 0xFE00000000000000, 0x1E000000, + 0x3E00000, 0x3F80, 0xD800000000000000, 0x3, 0x3000000000000F, 0xE80021E0, + 0x3F00000000000000, 0x20000000000, 0x2800F800, 0x40, 0xFFFFFE, + 0x1FFF0000000E, 0x7000000000000000, 0x800000000000000, 0x8000000000000000, + 0x7F, 0x7DC000000, 0x300000000003E, 0x180000000000000, 0x1F000000000000, + 0xC00000000000, 0x20000000000000, 0xF80000000000000, 0x10, 0x7800000, + 0xF80, 0xC0000000, + ], +}; + +pub const SEPARATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x100000000, 0, 0x100000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1, 0x8300000007FF, 0x80000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const SPACE_SEPARATOR: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x100000000, 0, 0x100000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1, 0x8000000007FF, 0x80000000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const SPACING_MARK: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 5, 7, 8, 4, 9, 10, 11, 12, 8, 13, 3, 14, 15, + 16, 0, 0, 0, 0, 9, 17, 0, 0, 18, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 0, 0, 0, 0, 23, 0, + 0, 0, 24, 25, 0, 0, 26, 27, 28, 29, 30, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 34, 35, 0, 36, 37, 6, 38, 39, 0, 40, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xC800000000000008, 0xDE01, 0xC00000000000000C, 0x801981, + 0xC000000000000008, 0x1, 0x1A01, 0x400000000000000C, 0xC000000000000000, + 0x801DC6, 0xE, 0x1E, 0x600D9F, 0x801DC1, 0xC, 0xC0000FF038000, + 0x8000000000000000, 0x1902180000000000, 0x3F9C00C00000, 0x1C009F98, + 0xC040000000000000, 0x1BF, 0x1FB0E7800000000, 0x6000000, 0x7E01A00A00000, + 0xE820000000000010, 0x1B, 0x4C200000004, 0xC5C8000000000, + 0x300FF000000000, 0x8C000200000000, 0xC00000000000, 0x9800000000, + 0xFFF0000000000003, 0xF, 0xC0000, 0xEC30000000000008, 0x19800000000000, + 0x2800000000002000, 0x20C80000000000, 0x16D800000000, + ], + tree3_level1: &[ + 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 3, 4, 5, 6, 7, 0, 0, + 8, 9, 10, 0, 0, 11, 12, 13, 14, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 0, + 19, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 0, 0, 0, 0, 0, 23, 0, 24, 0, 0, 0, + 25, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, + 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0x5, 0x187000000000004, 0x100000000000, 0x60, 0x8038000000000004, 0x1, + 0x2C700000000000, 0x700000000, 0xC00000000000000C, 0xC0080399E, + 0xE0000000000000, 0x23, 0x7A07000000000000, 0x2, 0x4F03800000000000, + 0x5807000000000000, 0x40D00000000000, 0x4300000000, 0x100700000000000, + 0x200000000000000, 0x1800000, 0x800000, 0x4000800000000000, + 0x12020000000000, 0x587C00, 0x60000000000000, 0x7FFFFFFFFFFE0000, + 0x7E06000000000, + ], +}; + +pub const SURROGATE: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFFFFFFFFFF, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const SYMBOL: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0x7000081000000000, 0x5000000140000000, 0x113D37C00000000, + 0x80000000800000, 0, 0, 0, 0, 0, 0, 0, 0xFFFFAFE0FFFC003C, 0, + 0x20000000000000, 0x30, 0x40000000000000, 0, 0, 0x4, 0, 0, 0, 0xE000, 0, + 0xC9C0, 0, 0, 0x6000020040000000, 0, 0, 0, 0xC040000000000000, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 4, 0, 5, 0, 0, 0, 6, 0, 0, 5, + 0, 0, 0, 7, 0, 8, 9, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 13, 0, 14, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, 0, + 18, 19, 0, 20, 21, 22, 23, 23, 23, 23, 23, 24, 23, 23, 23, 25, 26, 27, 28, + 23, 23, 23, 23, 23, 23, 23, 23, 23, 29, 30, 31, 23, 23, 23, 23, 23, 23, + 32, 33, 23, 23, 23, 23, 23, 34, 35, 36, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 38, + 39, 23, 23, 23, 40, 41, 0, 42, 0, 0, 0, 43, 44, 45, 46, 47, 48, 23, 23, + 23, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 51, 0, 52, 0, 53, 0, 0, 0, 0, + 0, 0, 0, 0, 54, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 55, 0, 56, 57, 0, 0, 0, 0, 0, 0, 0, 58, 0, 59, 0, 0, 60, 61, 0, + 62, + ], + tree2_level2: &[ + 0, 0xC0C000000000000, 0x2000000000000, 0x1000000000000, 0x7F8000000000000, + 0x8000000000000000, 0x200000000008000, 0x1500000FCE8000E, + 0xC000000000000000, 0x1E0DFBF, 0xC0000000, 0x3FF0000, 0x8000000, 0x1, + 0xFFFFFFFFC0000000, 0x1FF007FE00000000, 0xA000000000000000, + 0x6000E000E000E003, 0x1C00000000040010, 0xFFFFFFFF00001C00, + 0xC0042AFC1D0037B, 0xBC1F, 0xFFFFFFFFFFFF0C00, 0xFFFFFFFFFFFFFFFF, + 0xFFFFF9FFFFFFF0FF, 0x7FFFFFFFFF, 0x7FF, 0xFFFFFFFFF0000000, + 0x3FFFFFFFFFF, 0xFFFFFFFFFF, 0xFFFFFFFFFFF00000, 0xFFFF003FFFFFFF9F, + 0xFFFFFFFFFE000007, 0xCFFFFFFFF0FFFFFF, 0xFFCFFFFFFFFFFFFF, + 0xFFFFFFFFFF3FFFFF, 0x7FFFFFFFFFFFFDFF, 0x7E000000000, 0xFFFFFFFFFBFFFFFF, + 0xFFFFFFFFFFFFF, 0xFFF0000003FFFFF, 0xC0C00001000C0010, 0x18000000, + 0xFFC30000, 0xFFFFFFFFF, 0xFFFFFC007FFFFFFF, 0xFFFFFFFF000100FF, + 0x1FFFFFFFFFC00, 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF0000, 0x7F, + 0x3007FFFFF, 0x600, 0x3C00F0000000000, 0x380000000000000, 0x20000000000, + 0xFFFC000000000000, 0x3, 0x3000000000000000, 0x27400000000, + 0x4000000070000810, 0x50000001, 0x30007F7F00000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, 11, + 12, 13, 14, 15, 16, 11, 17, 0, 0, 11, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 19, 20, 21, 22, 23, 11, 11, 11, 11, 11, 11, 11, 11, 24, 25, 26, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 29, 11, 30, 31, 32, 29, 33, 34, 35, 36, 0, + 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 37, 11, 38, + 11, 39, 40, 41, 42, 0, 43, 44, 45, 46, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFF80000000000000, 0xFE00000000000000, 0x10FFF73FF, + 0x1FFFFFFFFFFF0000, 0x180000000000000, 0x100, 0x8000000000000000, + 0xF000000000000000, 0x20, 0x10000000, 0xFFFFFFFFFFFFFFFF, + 0x3FFFFFFFFFFFFF, 0xFFFFFE7FFFFFFFFF, 0x1C1FFFFFFFFF, 0xFFFFC3FFFFFFF018, + 0x1FFFFFFFFFF, 0x23, 0x7FFFFF, 0x800000008000002, 0x20000000200000, + 0x800000008000, 0x20000000200, 0x8, 0x780000000000000, 0xFFDFE00000000000, + 0x6F, 0x1100000000000, 0x3000000000000, 0xFFFF0FFFFFFFFFFF, + 0xFFFE7FFF000FFFFF, 0x3FFFFFFFFEFFFE, 0xFFFFFFFFFFFF0000, 0x1FFFFFFFFFFF, + 0xFFFFFFC000000000, 0xFFFFFFFFFFF0007, 0x3F000301FF, 0x3FF1FFF001FFFFF, + 0xFFFFFFFFFFFFF, 0x1FFFFFF, 0xFFFFFFFFFFFF0FFF, 0xFFFFFFFF03FF00FF, + 0x3FFFFFFF00FF, 0x7FFFFFFFFFFF0FFF, 0xF479FFFFFFFFFFFF, 0x3FF0007FFFFFFFF, + 0xFFFFFFFFFFFF0007, 0x3FFF00000000, + ], +}; + +pub const TITLECASE_LETTER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0x4000000000920, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0x1000FF00FF00FF00, 0x1000000000001000, + ], + tree3_level1: &[ + ], + tree3_level2: &[ + ], + tree3_level3: &[ + ], +}; + +pub const UNASSIGNED: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x300000000000000, 0x40000280F, 0, + 0, 0, 0, 0, 0x1000000000000, 0x1800000, 0x11800, 0xFFE078000000FF00, + 0x20000000, 0, 0, 0, 0x4000, 0x1800, 0xFFFC000000000000, + 0x1800000000000000, + ], + tree2_level1: &[ + 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 4, 27, 28, 29, 4, 4, 4, 30, 4, 4, 4, 4, 4, 31, + 32, 33, 34, 35, 36, 37, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 38, 39, 40, 41, 4, + 42, 43, 39, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 4, 54, 4, 55, 56, 57, + 58, 59, 4, 4, 4, 60, 4, 4, 4, 4, 61, 62, 63, 64, 4, 65, 66, 67, 4, 4, 68, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 69, 70, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 71, 72, 73, 74, 75, 4, 76, 77, + 78, 79, 80, 4, 81, 82, 83, 4, 4, 4, 84, 4, 85, 86, 4, 87, 4, 88, 89, 75, + 4, 4, 90, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 45, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 91, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 92, 93, 4, 4, 4, 4, 94, 4, 4, 95, 4, 4, 96, + 97, 98, 95, 4, 99, 4, 100, 4, 101, 102, 103, 4, 104, 105, 106, 4, 107, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 89, + 108, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 109, 4, 110, 111, 112, 4, 113, + 4, 4, 4, 4, 4, 114, 115, 116, 36, 117, 4, 118, 85, 4, 90, 119, + ], + tree2_level2: &[ + 0x8000C00000000000, 0xFFFFF800B0000000, 0xC0200000FFFFFFFF, 0x7FFFF, 0, + 0xC3A020000066010, 0x800000304F7F8660, 0x2C92020000067811, + 0xFF80003FA1FDC678, 0xC12020000044011, 0x1FC0030FFFEC440, + 0xC12020000066011, 0xFF0000304F3FC660, 0x3C0038E729C23813, + 0xF800003FFF7EC238, 0x1C00020000022000, 0xFF0030F89FC220, + 0xC10020000022000, 0xFFF90030BF9FC220, 0x22010, 0x30000F0220, + 0xD004000003800013, 0xFFE3003F00A07B80, 0x7800000000000001, + 0xFFFFFFFFF0000000, 0xC4001351010FDA69, 0xFFFFFFFF0C00C0A0, + 0x1E00000000100, 0x2000000001000000, 0xFFFFFFFFF8002000, 0xDF40, + 0xC280C200, 0x80C200000000C200, 0x8000C2, 0xC20000, 0xE000000018000000, + 0xFC000000, 0xC0C0000000000000, 0xE0000000, 0xFE00000000000000, + 0xFF800000FFE02000, 0xFFF22000FFF00000, 0xFC00FC00C0000000, 0xFC008000, + 0xF80000000000, 0xFFC0000000000000, 0xF000F00080000000, + 0xFFE0C0000000000E, 0xF00000000000, 0x3800FC00, 0x30000000, + 0x6000000080000000, 0x8000C000FC00FC00, 0xFFFFFFFFFFFFFFFF, + 0xE00000000000F000, 0xFF0000000000000, 0x700000000000000, 0x1C00, + 0x180000000000FE00, 0xFC0000000000FF00, 0x400000000000000, 0xC0C00000, + 0xC00000005500C0C0, 0x20000000000000, 0x8023000010300020, 0xC002000000000, + 0xE0008000, 0xFFFE00000000FFFF, 0xF000, 0xFFFFFF8000000000, 0xFFFFF800, + 0x30000000000000, 0xC00000, 0x8000000000000200, 0x800000000000, + 0x80000000, 0x1F0000000000000, 0xDF4000000000, 0x7FFE7F0000000000, + 0x80808080FF800000, 0x80808080, 0xFFFFFFFFFFFF8000, 0x4000000, + 0xFFF0000000000000, 0xF000FFFFFFC00000, 0x1, 0x1800000, 0x100000000001F, + 0xF800000000008000, 0xFFF000000000, 0x8000000000000000, + 0xFFFF000000000000, 0xE000, 0xFF80, 0xFFFFF00000000000, + 0xFF00000000000000, 0xFC00000000000000, 0x7FFFFFFFFFFFFF, + 0xFC00F00000000000, 0xFC003FC0, 0xE00000007FF00000, 0x800000003C004000, + 0xFF80000000000000, 0xC00C000, 0xFF80000007FFFFF8, 0x8080FF818181, + 0xFFC000000000, 0xFC00C00000000000, 0xF000000000000780, 0xC00000000000, + 0xFFFFFFFFFC000000, 0xA08000001F07FF80, 0x24, 0x7FFFC, 0xFFFF, 0x30000, + 0xC000FFFFFFFFFF00, 0x20F08000080000, 0x6000000000000000, + 0xC1FF8080E3030303, + ], + tree3_level1: &[ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 12, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 13, 14, 15, 7, 16, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 18, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 19, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 19, + ], + tree3_level2: &[ + 0, 1, 2, 3, 4, 2, 5, 6, 7, 7, 8, 9, 10, 11, 12, 13, 2, 2, 14, 15, 16, 17, + 7, 7, 2, 2, 2, 2, 18, 19, 7, 7, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 7, 2, 34, 35, 36, 37, 7, 7, 7, 7, 38, 7, 7, 16, 39, 7, 7, + 2, 40, 2, 41, 42, 43, 2, 44, 45, 7, 46, 47, 48, 49, 7, 7, 2, 50, 2, 51, 7, + 7, 52, 53, 2, 54, 55, 56, 57, 7, 7, 7, 58, 7, 59, 60, 7, 7, 7, 7, 2, 61, + 62, 63, 7, 7, 7, 7, 64, 65, 66, 7, 67, 68, 69, 7, 7, 7, 7, 70, 7, 7, 7, 7, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 39, 7, 2, 71, 2, 2, 2, 72, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 73, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 74, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, + 63, 75, 7, 76, 2, 77, 78, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 79, 7, 2, 80, + 81, 82, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 83, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 35, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 84, 85, 2, 2, 2, 2, 2, 58, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 2, 86, 87, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, + 2, 2, 88, 89, 2, 2, 90, 2, 91, 7, 92, 2, 93, 7, 7, 2, 94, 95, 96, 97, 98, + 2, 2, 2, 2, 99, 2, 2, 2, 2, 100, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 101, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 102, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 2, 2, 2, 103, 2, 104, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 105, 106, 7, + 7, 7, 7, 7, 107, 108, 109, 110, 7, 7, 7, 7, 111, 2, 112, 113, 114, 111, + 115, 116, 117, 118, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 119, 2, 120, 2, 121, 122, 123, 124, 7, 125, 126, 127, 128, 7, 129, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 130, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 106, 2, 2, 2, 131, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 132, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 133, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 53, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 134, 2, 7, + 7, 2, 2, 2, 135, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 136, + ], + tree3_level3: &[ + 0x4800008000001000, 0xFFFFFFFFC000C000, 0, 0xF800000000000000, + 0x70000000000078, 0xFFFFFFFEF0008000, 0xC00000000000FFFF, + 0xFFFFFFFFFFFFFFFF, 0xE0000000, 0xF0000000FFFE0000, 0x1FF000000000, + 0xF80000000000F800, 0x40000000, 0xFFFFFFFFFFC000F0, 0xFC00C0000000, + 0xF000000000F00000, 0xFF0000000000, 0xFFFF7FF000000000, + 0xFF80000000000000, 0xFFFFFF00FFC00000, 0x6E400000000002C0, 0x400000, + 0xFFFF007F80000000, 0x7C80000FFFFFFFF, 0x7C00000070000000, + 0xF00000000000000, 0x30000, 0x78C0000001100F90, 0xFE00FE00, + 0xFFFFFFFF00000000, 0xFF80078000000000, 0x1C0000000000000, + 0xF8000000C00000, 0xFFFF01FFE1FC0000, 0xFFFFFFFFFFFFFE00, + 0xFFF8000000000000, 0x3F8000000000000, 0xFC00FF0000000000, + 0x80000000FFFFFFFF, 0xFFFFFFFFFC000000, 0x7FFF00000003C000, + 0xFC00FE000000DFFC, 0x20000000000000, 0xFF8000000000FF80, + 0xFFE000010000C000, 0x8000000000040000, 0xFC0040004280, + 0xFC00F80000000000, 0x412020000066010, 0xFFE0E0301F7EC660, + 0xFFFFFFFF94000000, 0xFFFFFFFFFC00FF00, 0xC0000000000000, + 0xFFFFFFFFC0000000, 0xFFFFE000FC00FFE0, 0xFF00000000000000, + 0xFFFFFFFFFFFFFC00, 0xF00018000000, 0xF000000000000000, 0xFFFFFFFF, + 0x7FF8000000000000, 0xFF00, 0xFFFFFFF800000030, 0xFE00000000000000, + 0x80000000000200, 0xE0000000FFC0, 0xFF80010000030000, 0x4B80000000000480, + 0x240FC00FF00, 0xFFFFFC00FE048000, 0xFE000000FFFFFFFF, 0xFFE0800000000000, + 0xFFFFFFFFFFFFFFF0, 0xFFFF800000000000, 0xFFFFFFFFFFFFFF80, + 0xFFFF3C0080000000, 0xFFC0C0000000FFFF, 0x1F0000040400FFC0, + 0xFFFFFFFFFFFF0000, 0xFFFFFFFFF8000000, 0x800000000000FFE0, + 0xFFFFFFFF00007FFF, 0xFFFFFFFCFFFFFFFF, 0xFFFC000000000000, + 0xFFFFFFFF80000000, 0xFFFFFFFFFFFF, 0xE000F80000000000, + 0xFFFFFFF00C00FE00, 0xFFC0000000000000, 0x18000000000, 0xFFFFFE0000000000, + 0xFFFFFFFFFFFFFFC0, 0xFFF00000FFFFFFFF, 0xFE000000FF800000, 0x200000, + 0x1400219B20000000, 0x10, 0x8400000020201840, 0x203A0, 0xC000000000, + 0x3000, 0xFFFF000107FFF000, 0xFFFFF82406000080, 0xFFFFFFFFFF800060, + 0xFFFFFFFF3C00F800, 0x1FFFFFFFFFFFF, 0xFFE0000000000000, + 0xF508016900000010, 0xA10808695569157B, 0xF0000411F0000400, + 0xFFFCFFFFFFFFFFFF, 0xF00000000000, 0x18000FFF00000, 0xFFC0000000010001, + 0xE000, 0xFFFFE00000000000, 0x3FFFFFFFFF, 0xF00000000000FFF8, + 0xFFFFFFC0FFFCFE00, 0xFC00E000FFE00000, 0xFFF0000000000000, + 0xFFFFFFFFFE000000, 0xF000, 0xFC00FF00, 0xFFFFC0000000FF00, + 0x800000000000F000, 0xB86000000000000, 0xFC00FFF800000000, 0xFFF8, + 0xFFFFC000FFFFFFFF, 0xFFFFFFFFFF800000, 0xC0000000, 0xFFFC00000000, + 0xFFFFFFFE00000000, 0xFFFFFFFD, 0xFFFF000000000000, 0xC000000000000000, + ], +}; + +pub const UPPERCASE_LETTER: &'static ::ucd_trie::TrieSet = &::ucd_trie::TrieSet { + tree1_level1: &[ + 0, 0x7FFFFFE, 0, 0x7F7FFFFF, 0xAA55555555555555, 0x2B555555555554AA, + 0x11AED2D5B1DBCED6, 0x55D255554AAAA490, 0x6C05555555555555, 0x557A, 0, 0, + 0, 0x8045000000000000, 0xFFBFFFED740, 0xE6905555551C8000, 0xFFFFFFFFFFFF, + 0x5555555500000000, 0x5555555555555401, 0x5555555555552AAB, + 0xFFFE555555555555, 0x7FFFFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree2_level1: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 0, 0, + 0, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 15, 5, + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 18, 0, 19, 20, 21, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, + ], + tree2_level2: &[ + 0, 0xFFFFFFFF00000000, 0x20BF, 0x3FFFFFFFFFFFFF, 0xE7FFFFFFFFFF0000, + 0x5555555555555555, 0x5555555540155555, 0xFF00FF003F00FF00, + 0xFF00AA003F00, 0xF00000000000000, 0xF001F000F000F00, 0xC00F3D503E273884, + 0x20, 0x8, 0x7FFFFFFFFFFF, 0xC025EA9D00000000, 0x4280555555555, + 0x155555555555, 0x5555555, 0x5554555400000000, 0x6A00555555555555, + 0x15F7D5555452855, 0x7FFFFFE00000000, + ], + tree3_level1: &[ + 0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, + ], + tree3_level2: &[ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ], + tree3_level3: &[ + 0, 0xFFFFFFFFFF, 0xFFFF000000000000, 0xFFFFF, 0x7FFFFFFFFFFFF, + 0xFFFFFFFF00000000, 0xFFFFFFFF, 0xFFF0000003FFFFFF, 0xFFFFFF0000003FFF, + 0x3FDE64D0000003, 0x3FFFFFF0000, 0x7B0000001FDFE7B0, 0xFFFFF0000001FC5F, + 0x3FFFFFF0000003F, 0x3FFFFFF00000, 0xF0000003FFFFFF00, 0xFFFF0000003FFFFF, + 0xFFFFFF00000003FF, 0x7FFFFFC00000001, 0x1FFFFFF0000000, 0x7FFFFFC00000, + 0x1FFFFFF0000, 0x400, 0x3FFFFFFFF, + ], +}; diff --git a/vendor/pest/src/unicode/mod.rs b/vendor/pest/src/unicode/mod.rs new file mode 100644 index 000000000..3def67e34 --- /dev/null +++ b/vendor/pest/src/unicode/mod.rs @@ -0,0 +1,66 @@ +//! Character inclusion in binary or General_Category value Unicode sets. +//! +//! We rely on dead code elimination to remove the tables that aren't needed. + +#![allow(bad_style)] +#![allow(clippy::all)] + +macro_rules! char_property_functions { + {$( + mod $module:ident; + [$( + $prop:ident, + )*]; + )*} => {$( + #[allow(unused)] + mod $module; + $(pub fn $prop(c: char) -> bool { + self::$module::$prop.contains_char(c) + })* + )*}; +} + +char_property_functions! { + mod binary; + [ + // ASCII_HEX_DIGIT, // let this one be stripped out -- the full trie is wasteful for ASCII + ALPHABETIC, BIDI_CONTROL, CASE_IGNORABLE, CASED, CHANGES_WHEN_CASEFOLDED, + CHANGES_WHEN_CASEMAPPED, CHANGES_WHEN_LOWERCASED, CHANGES_WHEN_TITLECASED, + CHANGES_WHEN_UPPERCASED, DASH, DEFAULT_IGNORABLE_CODE_POINT, DEPRECATED, DIACRITIC, + EXTENDER, GRAPHEME_BASE, GRAPHEME_EXTEND, GRAPHEME_LINK, HEX_DIGIT, HYPHEN, + IDS_BINARY_OPERATOR, IDS_TRINARY_OPERATOR, ID_CONTINUE, ID_START, IDEOGRAPHIC, JOIN_CONTROL, + LOGICAL_ORDER_EXCEPTION, LOWERCASE, MATH, NONCHARACTER_CODE_POINT, OTHER_ALPHABETIC, + OTHER_DEFAULT_IGNORABLE_CODE_POINT, OTHER_GRAPHEME_EXTEND, OTHER_ID_CONTINUE, + OTHER_ID_START, OTHER_LOWERCASE, OTHER_MATH, OTHER_UPPERCASE, PATTERN_SYNTAX, + PATTERN_WHITE_SPACE, PREPENDED_CONCATENATION_MARK, QUOTATION_MARK, RADICAL, + REGIONAL_INDICATOR, SENTENCE_TERMINAL, SOFT_DOTTED, TERMINAL_PUNCTUATION, UNIFIED_IDEOGRAPH, + UPPERCASE, VARIATION_SELECTOR, WHITE_SPACE, XID_CONTINUE, XID_START, + ]; + + mod category; + [ + CASED_LETTER, CLOSE_PUNCTUATION, CONNECTOR_PUNCTUATION, CONTROL, CURRENCY_SYMBOL, + DASH_PUNCTUATION, DECIMAL_NUMBER, ENCLOSING_MARK, FINAL_PUNCTUATION, FORMAT, + INITIAL_PUNCTUATION, LETTER, LETTER_NUMBER, LINE_SEPARATOR, LOWERCASE_LETTER, MARK, + MATH_SYMBOL, MODIFIER_LETTER, MODIFIER_SYMBOL, NONSPACING_MARK, NUMBER, OPEN_PUNCTUATION, + OTHER, OTHER_LETTER, OTHER_NUMBER, OTHER_PUNCTUATION, OTHER_SYMBOL, PARAGRAPH_SEPARATOR, + PRIVATE_USE, PUNCTUATION, SEPARATOR, SPACE_SEPARATOR, SPACING_MARK, SURROGATE, SYMBOL, + TITLECASE_LETTER, UNASSIGNED, UPPERCASE_LETTER, + ]; +} + +pub fn by_name(name: &str) -> Option<Box<dyn Fn(char) -> bool>> { + for property in binary::BY_NAME { + if name == property.0.to_uppercase() { + return Some(Box::new(move |c| property.1.contains_char(c))); + } + } + + for property in category::BY_NAME { + if name == property.0.to_uppercase() { + return Some(Box::new(move |c| property.1.contains_char(c))); + } + } + + None +} diff --git a/vendor/pest/tests/calculator.rs b/vendor/pest/tests/calculator.rs new file mode 100644 index 000000000..b78ee0d27 --- /dev/null +++ b/vendor/pest/tests/calculator.rs @@ -0,0 +1,201 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[macro_use] +extern crate pest; + +use pest::error::Error; +use pest::iterators::{Pair, Pairs}; +use pest::prec_climber::{Assoc, Operator, PrecClimber}; +use pest::{state, ParseResult, Parser, ParserState}; + +#[allow(dead_code, non_camel_case_types)] +#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +enum Rule { + expression, + primary, + number, + plus, + minus, + times, + divide, + modulus, + power, +} + +struct CalculatorParser; + +impl Parser<Rule> for CalculatorParser { + fn parse(rule: Rule, input: &str) -> Result<Pairs<Rule>, Error<Rule>> { + fn expression(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::expression, |s| { + s.sequence(|s| { + primary(s).and_then(|s| { + s.repeat(|s| { + s.sequence(|s| { + plus(s) + .or_else(|s| minus(s)) + .or_else(|s| times(s)) + .or_else(|s| divide(s)) + .or_else(|s| modulus(s)) + .or_else(|s| power(s)) + .and_then(|s| primary(s)) + }) + }) + }) + }) + }) + } + + fn primary(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state + .sequence(|s| { + s.match_string("(") + .and_then(|s| expression(s)) + .and_then(|s| s.match_string(")")) + }) + .or_else(|s| number(s)) + } + + fn number(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::number, |s| { + s.sequence(|s| { + s.optional(|s| s.match_string("-")).and_then(|s| { + s.match_string("0").or_else(|s| { + s.sequence(|s| { + s.match_range('1'..'9') + .and_then(|s| s.repeat(|s| s.match_range('0'..'9'))) + }) + }) + }) + }) + }) + } + + fn plus(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::plus, |s| s.match_string("+")) + } + + fn minus(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::minus, |s| s.match_string("-")) + } + + fn times(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::times, |s| s.match_string("*")) + } + + fn divide(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::divide, |s| s.match_string("/")) + } + + fn modulus(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::modulus, |s| s.match_string("%")) + } + + fn power(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::power, |s| s.match_string("^")) + } + + state(input, |state| match rule { + Rule::expression => expression(state), + _ => unreachable!(), + }) + } +} + +fn consume<'i>(pair: Pair<'i, Rule>, climber: &PrecClimber<Rule>) -> i32 { + let primary = |pair| consume(pair, climber); + let infix = |lhs: i32, op: Pair<Rule>, rhs: i32| match op.as_rule() { + Rule::plus => lhs + rhs, + Rule::minus => lhs - rhs, + Rule::times => lhs * rhs, + Rule::divide => lhs / rhs, + Rule::modulus => lhs % rhs, + Rule::power => lhs.pow(rhs as u32), + _ => unreachable!(), + }; + + match pair.as_rule() { + Rule::expression => climber.climb(pair.into_inner(), primary, infix), + Rule::number => pair.as_str().parse().unwrap(), + _ => unreachable!(), + } +} + +#[test] +fn number() { + parses_to! { + parser: CalculatorParser, + input: "-12", + rule: Rule::expression, + tokens: [ + expression(0, 3, [ + number(0, 3) + ]) + ] + }; +} + +#[test] +fn parens() { + parses_to! { + parser: CalculatorParser, + input: "((-12))", + rule: Rule::expression, + tokens: [ + expression(0, 7, [ + expression(1, 6, [ + expression(2, 5, [ + number(2, 5) + ]) + ]) + ]) + ] + }; +} + +#[test] +fn expression() { + parses_to! { + parser: CalculatorParser, + input: "-12+3*(4-9)^7^2", + rule: Rule::expression, + tokens: [ + expression(0, 15, [ + number(0, 3), + plus(3, 4), + number(4, 5), + times(5, 6), + expression(7, 10, [ + number(7, 8), + minus(8, 9), + number(9, 10) + ]), + power(11, 12), + number(12, 13), + power(13, 14), + number(14, 15) + ]) + ] + }; +} + +#[test] +fn prec_climb() { + let climber = PrecClimber::new(vec![ + Operator::new(Rule::plus, Assoc::Left) | Operator::new(Rule::minus, Assoc::Left), + Operator::new(Rule::times, Assoc::Left) + | Operator::new(Rule::divide, Assoc::Left) + | Operator::new(Rule::modulus, Assoc::Left), + Operator::new(Rule::power, Assoc::Right), + ]); + + let pairs = CalculatorParser::parse(Rule::expression, "-12+3*(4-9)^3^2/9%7381"); + assert_eq!(-1_525, consume(pairs.unwrap().next().unwrap(), &climber)); +} diff --git a/vendor/pest/tests/json.rs b/vendor/pest/tests/json.rs new file mode 100644 index 000000000..84906258a --- /dev/null +++ b/vendor/pest/tests/json.rs @@ -0,0 +1,465 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[macro_use] +extern crate pest; + +use std::collections::HashMap; + +use pest::error::Error; +use pest::iterators::{Pair, Pairs}; +use pest::{state, ParseResult, Parser, ParserState, Span}; + +#[allow(dead_code, non_camel_case_types)] +#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +enum Rule { + json, + object, + pair, + array, + value, + string, + escape, + unicode, + hex, + number, + int, + exp, + bool, + null, +} + +struct JsonParser; + +impl Parser<Rule> for JsonParser { + fn parse(rule: Rule, input: &str) -> Result<Pairs<Rule>, Error<Rule>> { + fn json(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + value(state) + } + + fn object(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::object, |s| { + s.sequence(|s| { + s.match_string("{") + .and_then(|s| skip(s)) + .and_then(|s| pair(s)) + .and_then(|s| skip(s)) + .and_then(|s| { + s.repeat(|s| { + s.sequence(|s| { + s.match_string(",") + .and_then(|s| skip(s)) + .and_then(|s| pair(s)) + .and_then(|s| skip(s)) + }) + }) + }) + .and_then(|s| s.match_string("}")) + }) + .or_else(|s| { + s.sequence(|s| { + s.match_string("{") + .and_then(|s| skip(s)) + .and_then(|s| s.match_string("}")) + }) + }) + }) + } + + fn pair(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::pair, |s| { + s.sequence(|s| { + string(s) + .and_then(|s| skip(s)) + .and_then(|s| s.match_string(":")) + .and_then(|s| skip(s)) + .and_then(|s| value(s)) + }) + }) + } + + fn array(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::array, |s| { + s.sequence(|s| { + s.match_string("[") + .and_then(|s| skip(s)) + .and_then(|s| value(s)) + .and_then(|s| skip(s)) + .and_then(|s| { + s.repeat(|s| { + s.sequence(|s| { + s.match_string(",") + .and_then(|s| skip(s)) + .and_then(|s| value(s)) + .and_then(|s| skip(s)) + }) + }) + }) + .and_then(|s| s.match_string("]")) + }) + .or_else(|s| { + s.sequence(|s| { + s.match_string("[") + .and_then(|s| skip(s)) + .and_then(|s| s.match_string("]")) + }) + }) + }) + } + + fn value(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::value, |s| { + string(s) + .or_else(|s| number(s)) + .or_else(|s| object(s)) + .or_else(|s| array(s)) + .or_else(|s| bool(s)) + .or_else(|s| null(s)) + }) + } + + fn string(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::string, |s| { + s.match_string("\"") + .and_then(|s| { + s.repeat(|s| { + escape(s).or_else(|s| { + s.sequence(|s| { + s.lookahead(false, |s| { + s.match_string("\"").or_else(|s| s.match_string("\\")) + }) + .and_then(|s| s.skip(1)) + }) + }) + }) + }) + .and_then(|pos| pos.match_string("\"")) + }) + } + + fn escape(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.sequence(|s| { + s.match_string("\\").and_then(|s| { + s.match_string("\"") + .or_else(|s| s.match_string("\\")) + .or_else(|s| s.match_string("/")) + .or_else(|s| s.match_string("b")) + .or_else(|s| s.match_string("f")) + .or_else(|s| s.match_string("n")) + .or_else(|s| s.match_string("r")) + .or_else(|s| s.match_string("t")) + .or_else(|s| unicode(s)) + }) + }) + } + + fn unicode(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.sequence(|s| { + s.match_string("u") + .and_then(|s| hex(s)) + .and_then(|s| hex(s)) + .and_then(|s| hex(s)) + }) + } + + fn hex(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state + .match_range('0'..'9') + .or_else(|s| s.match_range('a'..'f')) + .or_else(|s| s.match_range('A'..'F')) + } + + fn number(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::number, |s| { + s.sequence(|s| { + s.optional(|s| s.match_string("-")) + .and_then(|s| int(s)) + .and_then(|s| { + s.optional(|s| { + s.sequence(|s| { + s.match_string(".") + .and_then(|s| s.match_range('0'..'9')) + .and_then(|s| s.repeat(|s| s.match_range('0'..'9'))) + .and_then(|s| s.optional(|s| exp(s))) + .or_else(|s| exp(s)) + }) + }) + }) + }) + }) + } + + fn int(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.match_string("0").or_else(|s| { + s.sequence(|s| { + s.match_range('1'..'9') + .and_then(|s| s.repeat(|s| s.match_range('0'..'9'))) + }) + }) + } + + fn exp(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.sequence(|s| { + s.match_string("E") + .or_else(|s| s.match_string("e")) + .and_then(|s| { + s.optional(|s| s.match_string("+").or_else(|s| s.match_string("-"))) + }) + .and_then(|s| int(s)) + }) + } + + fn bool(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::bool, |s| { + s.match_string("true").or_else(|s| s.match_string("false")) + }) + } + + fn null(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.rule(Rule::null, |s| s.match_string("null")) + } + + fn skip(state: Box<ParserState<Rule>>) -> ParseResult<Box<ParserState<Rule>>> { + state.repeat(|s| { + s.match_string(" ") + .or_else(|s| s.match_string("\t")) + .or_else(|s| s.match_string("\r")) + .or_else(|s| s.match_string("\n")) + }) + } + + state(input, |state| match rule { + Rule::json => json(state), + Rule::object => object(state), + Rule::pair => pair(state), + Rule::array => array(state), + Rule::value => value(state), + Rule::string => string(state), + Rule::escape => escape(state), + Rule::unicode => unicode(state), + Rule::hex => hex(state), + Rule::number => number(state), + Rule::int => int(state), + Rule::exp => exp(state), + Rule::bool => bool(state), + Rule::null => null(state), + }) + } +} + +#[derive(Debug, PartialEq)] +enum Json<'i> { + Null, + Bool(bool), + Number(f64), + String(Span<'i>), + Array(Vec<Json<'i>>), + Object(HashMap<Span<'i>, Json<'i>>), +} + +fn consume(pair: Pair<Rule>) -> Json { + fn value(pair: Pair<Rule>) -> Json { + let pair = pair.into_inner().next().unwrap(); + + match pair.as_rule() { + Rule::null => Json::Null, + Rule::bool => match pair.as_str() { + "false" => Json::Bool(false), + "true" => Json::Bool(true), + _ => unreachable!(), + }, + Rule::number => Json::Number(pair.as_str().parse().unwrap()), + Rule::string => Json::String(pair.as_span()), + Rule::array => Json::Array(pair.into_inner().map(value).collect()), + Rule::object => { + let pairs = pair.into_inner().map(|pos| { + let mut pair = pos.into_inner(); + + let key = pair.next().unwrap().as_span(); + let value = value(pair.next().unwrap()); + + (key, value) + }); + + Json::Object(pairs.collect()) + } + _ => unreachable!(), + } + } + + value(pair) +} + +#[test] +fn null() { + parses_to! { + parser: JsonParser, + input: "null", + rule: Rule::null, + tokens: [ + null(0, 4) + ] + }; +} + +#[test] +fn bool() { + parses_to! { + parser: JsonParser, + input: "false", + rule: Rule::bool, + tokens: [ + bool(0, 5) + ] + }; +} + +#[test] +fn number_zero() { + parses_to! { + parser: JsonParser, + input: "0", + rule: Rule::number, + tokens: [ + number(0, 1) + ] + }; +} + +#[test] +fn float() { + parses_to! { + parser: JsonParser, + input: "100.001", + rule: Rule::number, + tokens: [ + number(0, 7) + ] + }; +} + +#[test] +fn float_with_exp() { + parses_to! { + parser: JsonParser, + input: "100.001E+100", + rule: Rule::number, + tokens: [ + number(0, 12) + ] + }; +} + +#[test] +fn number_minus_zero() { + parses_to! { + parser: JsonParser, + input: "-0", + rule: Rule::number, + tokens: [ + number(0, 2) + ] + }; +} + +#[test] +fn string_with_escapes() { + parses_to! { + parser: JsonParser, + input: "\"asd\\u0000\\\"\"", + rule: Rule::string, + tokens: [ + string(0, 13) + ] + }; +} + +#[test] +fn array_empty() { + parses_to! { + parser: JsonParser, + input: "[ ]", + rule: Rule::array, + tokens: [ + array(0, 3) + ] + }; +} + +#[test] +fn array() { + parses_to! { + parser: JsonParser, + input: "[0.0e1, false, null, \"a\", [0]]", + rule: Rule::array, + tokens: [ + array(0, 30, [ + value(1, 6, [number(1, 6)]), + value(8, 13, [bool(8, 13)]), + value(15, 19, [null(15, 19)]), + value(21, 24, [string(21, 24)]), + value(26, 29, [ + array(26, 29, [ + value(27, 28, [number(27, 28)]) + ]) + ]) + ]) + ] + }; +} + +#[test] +fn object() { + parses_to! { + parser: JsonParser, + input: "{\"a\" : 3, \"b\" : [{}, 3]}", + rule: Rule::object, + tokens: [ + object(0, 24, [ + pair(1, 8, [ + string(1, 4), + value(7, 8, [number(7, 8)]) + ]), + pair(10, 23, [ + string(10, 13), + value(16, 23, [ + array(16, 23, [ + value(17, 19, [object(17, 19)]), + value(21, 22, [number(21, 22)]) + ]) + ]) + ]) + ]) + ] + }; +} + +#[test] +fn ast() { + let input = "{\"a\": [null, true, 3.4]}"; + + let ast = consume( + JsonParser::parse(Rule::json, input) + .unwrap() + .next() + .unwrap(), + ); + + match ast { + Json::Object(pairs) => { + let vals: Vec<&Json> = pairs.values().collect(); + + assert_eq!( + **vals.get(0).unwrap(), + Json::Array(vec![Json::Null, Json::Bool(true), Json::Number(3.4)]) + ); + } + _ => {} + } +} diff --git a/vendor/pest_derive/.cargo-checksum.json b/vendor/pest_derive/.cargo-checksum.json new file mode 100644 index 000000000..0f484603a --- /dev/null +++ b/vendor/pest_derive/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"3616e31e313d646dd0372ba0116b596a4c9dfc21cda88625ef00001ab13b0d68","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","_README.md":"7c31c505c267ac538b70deaa9ad95ef0cc68720c46b4d3276df8f3a278d233e2","src/lib.rs":"f343c474ce5ff5520907bd69dd52b965b4aec42750fe3bf7eaf2b5075b08cfd6","tests/grammar.pest":"3a2212c28dd560ba3169e0e1470394ae706eb9336360ecdc0f1d9934af9fc223","tests/grammar.rs":"75261bc1ba2817d59e35fa2a7c07a661f9f2200a0144cb768837d37d3c370aa0","tests/grammar_inline.rs":"675c55697df7b8d011cef7182f2b05d52b4e73d405c869b9ea361bff5f17b63a","tests/lists.pest":"96d90ad5eb7b14648fa8720f0a48e680327080b07251a4dd74e1a023625e9c1a","tests/lists.rs":"5cc0c79494685d5056ab6164bc8893e26d29810f5c5a20d895f27c1695bab31c","tests/reporting.pest":"f5bc8405ea117b76338e0003e359731a8aaf1a36672f31a6a639a4e67a65e331","tests/reporting.rs":"d1658fd9466278f80769384f4377056274bd06fff586c2422b4fe42d39967e4b"},"package":"833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"}
\ No newline at end of file diff --git a/vendor/pest_derive/Cargo.toml b/vendor/pest_derive/Cargo.toml new file mode 100644 index 000000000..47dfec41b --- /dev/null +++ b/vendor/pest_derive/Cargo.toml @@ -0,0 +1,41 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g. crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "pest_derive" +version = "2.1.0" +authors = ["Dragoș Tiselice <dragostiselice@gmail.com>"] +description = "pest's derive macro" +homepage = "https://pest-parser.github.io/" +documentation = "https://docs.rs/pest" +readme = "_README.md" +keywords = ["pest", "parser", "peg", "grammar"] +categories = ["parsing"] +license = "MIT/Apache-2.0" +repository = "https://github.com/pest-parser/pest" + +[lib] +name = "pest_derive" +proc-macro = true +[dependencies.pest] +version = "2.1.0" + +[dependencies.pest_generator] +version = "2.1.0" +[badges.codecov] +repository = "pest-parser/pest" + +[badges.maintenance] +status = "actively-developed" + +[badges.travis-ci] +repository = "pest-parser/pest" diff --git a/vendor/pest_derive/LICENSE-APACHE b/vendor/pest_derive/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/vendor/pest_derive/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/pest_derive/LICENSE-MIT b/vendor/pest_derive/LICENSE-MIT new file mode 100644 index 000000000..31aa79387 --- /dev/null +++ b/vendor/pest_derive/LICENSE-MIT @@ -0,0 +1,23 @@ +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/pest_derive/_README.md b/vendor/pest_derive/_README.md new file mode 100644 index 000000000..2c94a7222 --- /dev/null +++ b/vendor/pest_derive/_README.md @@ -0,0 +1,167 @@ +<p align="center"> + <img src="https://raw.github.com/pest-parser/pest/master/pest-logo.svg?sanitize=true" width="80%"/> +</p> + +# pest. The Elegant Parser + +[![Join the chat at https://gitter.im/dragostis/pest](https://badges.gitter.im/dragostis/pest.svg)](https://gitter.im/dragostis/pest?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[![Book](https://img.shields.io/badge/book-WIP-4d76ae.svg)](https://pest-parser.github.io/book) +[![Docs](https://docs.rs/pest/badge.svg)](https://docs.rs/pest) + +[![Build Status](https://travis-ci.org/pest-parser/pest.svg?branch=master)](https://travis-ci.org/pest-parser/pest) +[![codecov](https://codecov.io/gh/pest-parser/pest/branch/master/graph/badge.svg)](https://codecov.io/gh/pest-parser/pest) +[![Crates.io](https://img.shields.io/crates/d/pest.svg)](https://crates.io/crates/pest) +[![Crates.io](https://img.shields.io/crates/v/pest.svg)](https://crates.io/crates/pest) + +pest is a general purpose parser written in Rust with a focus on accessibility, +correctness, and performance. It uses parsing expression grammars +(or [PEG]) as input, which are similar in spirit to regular expressions, but +which offer the enhanced expressivity needed to parse complex languages. + +[PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar + +## Getting started + +The recommended way to start parsing with pest is to read the official [book]. + +Other helpful resources: + +* API reference on [docs.rs] +* play with grammars and share them on our [fiddle] +* leave feedback, ask questions, or greet us on [Gitter] + +[book]: https://pest-parser.github.io/book +[docs.rs]: https://docs.rs/pest +[fiddle]: https://pest-parser.github.io/#editor +[Gitter]: https://gitter.im/dragostis/pest + +## Example + +The following is an example of a grammar for a list of alpha-numeric identifiers +where the first identifier does not start with a digit: + +```rust +alpha = { 'a'..'z' | 'A'..'Z' } +digit = { '0'..'9' } + +ident = { (alpha | digit)+ } + +ident_list = _{ !digit ~ ident ~ (" " ~ ident)+ } + // ^ + // ident_list rule is silent which means it produces no tokens +``` + +Grammars are saved in separate .pest files which are never mixed with procedural +code. This results in an always up-to-date formalization of a language that is +easy to read and maintain. + +## Meaningful error reporting + +Based on the grammar definition, the parser also includes automatic error +reporting. For the example above, the input `"123"` will result in: + +``` +thread 'main' panicked at ' --> 1:1 + | +1 | 123 + | ^--- + | + = unexpected digit', src/main.rs:12 +``` +while `"ab *"` will result in: +``` +thread 'main' panicked at ' --> 1:1 + | +1 | ab * + | ^--- + | + = expected ident', src/main.rs:12 +``` + +## Pairs API + +The grammar can be used to derive a `Parser` implementation automatically. +Parsing returns an iterator of nested token pairs: + +```rust +extern crate pest; +#[macro_use] +extern crate pest_derive; + +use pest::Parser; + +#[derive(Parser)] +#[grammar = "ident.pest"] +struct IdentParser; + +fn main() { + let pairs = IdentParser::parse(Rule::ident_list, "a1 b2").unwrap_or_else(|e| panic!("{}", e)); + + // Because ident_list is silent, the iterator will contain idents + for pair in pairs { + + let span = pair.clone().into_span(); + // A pair is a combination of the rule which matched and a span of input + println!("Rule: {:?}", pair.as_rule()); + println!("Span: {:?}", span); + println!("Text: {}", span.as_str()); + + // A pair can be converted to an iterator of the tokens which make it up: + for inner_pair in pair.into_inner() { + let inner_span = inner_pair.clone().into_span(); + match inner_pair.as_rule() { + Rule::alpha => println!("Letter: {}", inner_span.as_str()), + Rule::digit => println!("Digit: {}", inner_span.as_str()), + _ => unreachable!() + }; + } + } +} +``` + +This produces the following output: +``` +Rule: ident +Span: Span { start: 0, end: 2 } +Text: a1 +Letter: a +Digit: 1 +Rule: ident +Span: Span { start: 3, end: 5 } +Text: b2 +Letter: b +Digit: 2 +``` + +## Other features + +* Precedence climbing +* Input handling +* Custom errors +* Runs on stable Rust + +## Projects using pest + +* [pest_meta](https://github.com/pest-parser/pest/blob/master/meta/src/grammar.pest) (bootstrapped) +* [brain](https://github.com/brain-lang/brain) +* [Chelone](https://github.com/Aaronepower/chelone) +* [comrak](https://github.com/kivikakk/comrak) +* [graphql-parser](https://github.com/Keats/graphql-parser) +* [handlebars-rust](https://github.com/sunng87/handlebars-rust) +* [hexdino](https://github.com/Luz/hexdino) +* [Huia](https://gitlab.com/jimsy/huia/) +* [json5-rs](https://github.com/callum-oakley/json5-rs) +* [mt940](https://github.com/svenstaro/mt940-rs) +* [py_literal](https://github.com/jturner314/py_literal) +* [rouler](https://github.com/jarcane/rouler) +* [RuSh](https://github.com/lwandrebeck/RuSh) +* [rs_pbrt](https://github.com/wahn/rs_pbrt) +* [stache](https://github.com/dgraham/stache) +* [tera](https://github.com/Keats/tera) +* [ui_gen](https://github.com/emoon/ui_gen) +* [ukhasnet-parser](https://github.com/adamgreig/ukhasnet-parser) + +## Special thanks + +A special round of applause goes to prof. Marius Minea for his guidance and all +pest contributors, some of which being none other than my friends. diff --git a/vendor/pest_derive/src/lib.rs b/vendor/pest_derive/src/lib.rs new file mode 100644 index 000000000..f60d5d943 --- /dev/null +++ b/vendor/pest_derive/src/lib.rs @@ -0,0 +1,302 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +//! # pest. The Elegant Parser +//! +//! pest is a general purpose parser written in Rust with a focus on accessibility, correctness, +//! and performance. It uses parsing expression grammars (or [PEG]) as input, which are similar in +//! spirit to regular expressions, but which offer the enhanced expressivity needed to parse +//! complex languages. +//! +//! [PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar +//! +//! ## Getting started +//! +//! The recommended way to start parsing with pest is to read the official [book]. +//! +//! Other helpful resources: +//! +//! * API reference on [docs.rs] +//! * play with grammars and share them on our [fiddle] +//! * leave feedback, ask questions, or greet us on [Gitter] +//! +//! [book]: https://pest-parser.github.io/book +//! [docs.rs]: https://docs.rs/pest +//! [fiddle]: https://pest-parser.github.io/#editor +//! [Gitter]: https://gitter.im/dragostis/pest +//! +//! ## `.pest` files +//! +//! Grammar definitions reside in custom `.pest` files located in the `src` directory. Their path is +//! relative to `src` and is specified between the `derive` attribute and empty `struct` that +//! `Parser` will be derived on. +//! +//! ```ignore +//! #[derive(Parser)] +//! #[grammar = "path/to/my_grammar.pest"] // relative to src +//! struct MyParser; +//! ``` +//! +//! ## Inline grammars +//! +//! Grammars can also be inlined by using the `#[grammar_inline = "..."]` attribute. +//! +//! ## Grammar +//! +//! A grammar is a series of rules separated by whitespace, possibly containing comments. +//! +//! ### Comments +//! +//! Comments start with `//` and end at the end of the line. +//! +//! ```ignore +//! // a comment +//! ``` +//! +//! ### Rules +//! +//! Rules have the following form: +//! +//! ```ignore +//! name = optional_modifier { expression } +//! ``` +//! +//! The name of the rule is formed from alphanumeric characters or `_` with the condition that the +//! first character is not a digit and is used to create token pairs. When the rule starts being +//! parsed, the starting part of the token is being produced, with the ending part being produced +//! when the rule finishes parsing. +//! +//! The following token pair notation `a(b(), c())` denotes the tokens: start `a`, start `b`, end +//! `b`, start `c`, end `c`, end `a`. +//! +//! #### Modifiers +//! +//! Modifiers are optional and can be one of `_`, `@`, `$`, or `!`. These modifiers change the +//! behavior of the rules. +//! +//! 1. Silent (`_`) +//! +//! Silent rules do not create token pairs during parsing, nor are they error-reported. +//! +//! ```ignore +//! a = _{ "a" } +//! b = { a ~ "b" } +//! ``` +//! +//! Parsing `"ab"` produces the token pair `b()`. +//! +//! 2. Atomic (`@`) +//! +//! Atomic rules do not accept whitespace or comments within their expressions and have a +//! cascading effect on any rule they call. I.e. rules that are not atomic but are called by atomic +//! rules behave atomically. +//! +//! Any rules called by atomic rules do not generate token pairs. +//! +//! ```ignore +//! a = { "a" } +//! b = @{ a ~ "b" } +//! +//! WHITESPACE = _{ " " } +//! ``` +//! +//! Parsing `"ab"` produces the token pair `b()`, while `"a b"` produces an error. +//! +//! 3. Compound-atomic (`$`) +//! +//! Compound-atomic are identical to atomic rules with the exception that rules called by them are +//! not forbidden from generating token pairs. +//! +//! ```ignore +//! a = { "a" } +//! b = ${ a ~ "b" } +//! +//! WHITESPACE = _{ " " } +//! ``` +//! +//! Parsing `"ab"` produces the token pairs `b(a())`, while `"a b"` produces an error. +//! +//! 4. Non-atomic (`!`) +//! +//! Non-atomic are identical to normal rules with the exception that they stop the cascading effect +//! of atomic and compound-atomic rules. +//! +//! ```ignore +//! a = { "a" } +//! b = !{ a ~ "b" } +//! c = @{ b } +//! +//! WHITESPACE = _{ " " } +//! ``` +//! +//! Parsing both `"ab"` and `"a b"` produce the token pairs `c(a())`. +//! +//! #### Expressions +//! +//! Expressions can be either terminals or non-terminals. +//! +//! 1. Terminals +//! +//! | Terminal | Usage | +//! |------------|----------------------------------------------------------------| +//! | `"a"` | matches the exact string `"a"` | +//! | `^"a"` | matches the exact string `"a"` case insensitively (ASCII only) | +//! | `'a'..'z'` | matches one character between `'a'` and `'z'` | +//! | `a` | matches rule `a` | +//! +//! Strings and characters follow +//! [Rust's escape mechanisms](https://doc.rust-lang.org/reference/tokens.html#byte-escapes), while +//! identifiers can contain alpha-numeric characters and underscores (`_`), as long as they do not +//! start with a digit. +//! +//! 2. Non-terminals +//! +//! | Non-terminal | Usage | +//! |-----------------------|------------------------------------------------------------| +//! | `(e)` | matches `e` | +//! | `e1 ~ e2` | matches the sequence `e1` `e2` | +//! | <code>e1 \| e2</code> | matches either `e1` or `e2` | +//! | `e*` | matches `e` zero or more times | +//! | `e+` | matches `e` one or more times | +//! | `e{n}` | matches `e` exactly `n` times | +//! | `e{, n}` | matches `e` at most `n` times | +//! | `e{n,} ` | matches `e` at least `n` times | +//! | `e{m, n}` | matches `e` between `m` and `n` times inclusively | +//! | `e?` | optionally matches `e` | +//! | `&e` | matches `e` without making progress | +//! | `!e` | matches if `e` doesn't match without making progress | +//! | `PUSH(e)` | matches `e` and pushes it's captured string down the stack | +//! +//! where `e`, `e1`, and `e2` are expressions. +//! +//! Expressions can modify the stack only if they match the input. For example, +//! if `e1` in the compound expression `e1 | e2` does not match the input, then +//! it does not modify the stack, so `e2` sees the stack in the same state as +//! `e1` did. Repetitions and optionals (`e*`, `e+`, `e{, n}`, `e{n,}`, +//! `e{m,n}`, `e?`) can modify the stack each time `e` matches. The `!e` and `&e` +//! expressions are a special case; they never modify the stack. +//! +//! ## Special rules +//! +//! Special rules can be called within the grammar. They are: +//! +//! * `WHITESPACE` - runs between rules and sub-rules +//! * `COMMENT` - runs between rules and sub-rules +//! * `ANY` - matches exactly one `char` +//! * `SOI` - (start-of-input) matches only when a `Parser` is still at the starting position +//! * `EOI` - (end-of-input) matches only when a `Parser` has reached its end +//! * `POP` - pops a string from the stack and matches it +//! * `POP_ALL` - pops the entire state of the stack and matches it +//! * `PEEK` - peeks a string from the stack and matches it +//! * `PEEK[a..b]` - peeks part of the stack and matches it +//! * `PEEK_ALL` - peeks the entire state of the stack and matches it +//! * `DROP` - drops the top of the stack (fails to match if the stack is empty) +//! +//! `WHITESPACE` and `COMMENT` should be defined manually if needed. All other rules cannot be +//! overridden. +//! +//! ## `WHITESPACE` and `COMMENT` +//! +//! When defined, these rules get matched automatically in sequences (`~`) and repetitions +//! (`*`, `+`) between expressions. Atomic rules and those rules called by atomic rules are exempt +//! from this behavior. +//! +//! These rules should be defined so as to match one whitespace character and one comment only since +//! they are run in repetitions. +//! +//! If both `WHITESPACE` and `COMMENT` are defined, this grammar: +//! +//! ```ignore +//! a = { b ~ c } +//! ``` +//! +//! is effectively transformed into this one behind the scenes: +//! +//! ```ignore +//! a = { b ~ WHITESPACE* ~ (COMMENT ~ WHITESPACE*)* ~ c } +//! ``` +//! +//! ## `PUSH`, `POP`, `DROP`, and `PEEK` +//! +//! `PUSH(e)` simply pushes the captured string of the expression `e` down a stack. This stack can +//! then later be used to match grammar based on its content with `POP` and `PEEK`. +//! +//! `PEEK` always matches the string at the top of stack. So, if the stack contains `["b", "a"]` +//! (`"a"` being on top), this grammar: +//! +//! ```ignore +//! a = { PEEK } +//! ``` +//! +//! is effectively transformed into at parse time: +//! +//! ```ignore +//! a = { "a" } +//! ``` +//! +//! `POP` works the same way with the exception that it pops the string off of the stack if the +//! match worked. With the stack from above, if `POP` matches `"a"`, the stack will be mutated +//! to `["b"]`. +//! +//! `DROP` makes it possible to remove the string at the top of the stack +//! without matching it. If the stack is nonempty, `DROP` drops the top of the +//! stack. If the stack is empty, then `DROP` fails to match. +//! +//! ### Advanced peeking +//! +//! `PEEK[start..end]` and `PEEK_ALL` allow to peek deeper into the stack. The syntax works exactly +//! like Rust’s exclusive slice syntax. Additionally, negative indices can be used to indicate an +//! offset from the top. If the end lies before or at the start, the expression matches (as does +//! a `PEEK_ALL` on an empty stack). With the stack `["c", "b", "a"]` (`"a"` on top): +//! +//! ```ignore +//! fill = PUSH("c") ~ PUSH("b") ~ PUSH("a") +//! v = { PEEK_ALL } = { "a" ~ "b" ~ "c" } // top to bottom +//! w = { PEEK[..] } = { "c" ~ "b" ~ "a" } // bottom to top +//! x = { PEEK[1..2] } = { PEEK[1..-1] } = { "b" } +//! y = { PEEK[..-2] } = { PEEK[0..1] } = { "a" } +//! z = { PEEK[1..] } = { PEEK[-2..3] } = { "c" ~ "b" } +//! n = { PEEK[2..-2] } = { PEEK[2..1] } = { "" } +//! ``` +//! +//! For historical reasons, `PEEK_ALL` matches from top to bottom, while `PEEK[start..end]` matches +//! from bottom to top. There is currectly no syntax to match a slice of the stack top to bottom. +//! +//! ## `Rule` +//! +//! All rules defined or used in the grammar populate a generated `enum` called `Rule`. This +//! implements `pest`'s `RuleType` and can be used throughout the API. +//! +//! ## `Built-in rules` +//! +//! Pest also comes with a number of built-in rules for convenience. They are: +//! +//! * `ASCII_DIGIT` - matches a numeric character from 0..9 +//! * `ASCII_NONZERO_DIGIT` - matches a numeric character from 1..9 +//! * `ASCII_BIN_DIGIT` - matches a numeric character from 0..1 +//! * `ASCII_OCT_DIGIT` - matches a numeric character from 0..7 +//! * `ASCII_HEX_DIGIT` - matches a numeric character from 0..9 or a..f or A..F +//! * `ASCII_ALPHA_LOWER` - matches a character from a..z +//! * `ASCII_ALPHA_UPPER` - matches a character from A..Z +//! * `ASCII_ALPHA` - matches a character from a..z or A..Z +//! * `ASCII_ALPHANUMERIC` - matches a character from a..z or A..Z or 0..9 +//! * `ASCII` - matches a character from \x00..\x7f +//! * `NEWLINE` - matches either "\n" or "\r\n" or "\r" + +#![doc(html_root_url = "https://docs.rs/pest_derive")] + +extern crate pest_generator; +extern crate proc_macro; + +use proc_macro::TokenStream; + +#[proc_macro_derive(Parser, attributes(grammar, grammar_inline))] +pub fn derive_parser(input: TokenStream) -> TokenStream { + pest_generator::derive_parser(input.into(), true).into() +} diff --git a/vendor/pest_derive/tests/grammar.pest b/vendor/pest_derive/tests/grammar.pest new file mode 100644 index 000000000..43a7b8cfd --- /dev/null +++ b/vendor/pest_derive/tests/grammar.pest @@ -0,0 +1,83 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +string = { "abc" } +insensitive = { ^"abc" } +range = { '0'..'9' } +ident = { string } +pos_pred = { &string } +neg_pred = { !string } +double_neg_pred = { !!string } +sequence = !{ string ~ string } +sequence_compound = ${ string ~ string } +sequence_atomic = @{ string ~ string } +sequence_non_atomic = @{ sequence } +sequence_atomic_compound = @{ sequence_compound } +sequence_nested = { string ~ string } +sequence_compound_nested = ${ sequence_nested } +choice = { string | range } +optional = { string? } +repeat = { string* } +repeat_atomic = @{ string* } +repeat_once = { string+ } +repeat_once_atomic = @{ string+ } +repeat_min_max = { string{2, 3} } +repeat_min_max_atomic = @{ string{2, 3} } +repeat_exact = { string{2} } +repeat_min = { string{2,} } +repeat_min_atomic = @{ string{2,} } +repeat_max = { string{, 2} } +repeat_max_atomic = @{ string{, 2} } +soi_at_start = { SOI ~ string } +repeat_mutate_stack = { (PUSH('a'..'c') ~ ",")* ~ POP ~ POP ~ POP } +peek_ = { PUSH(range) ~ PUSH(range) ~ PEEK ~ PEEK } +peek_all = { PUSH(range) ~ PUSH(range) ~ PEEK_ALL } +peek_slice_23 = { PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PUSH(range) ~ PEEK[1..-2] } +pop_ = { PUSH(range) ~ PUSH(range) ~ POP ~ POP } +pop_all = { PUSH(range) ~ PUSH(range) ~ POP_ALL } +pop_fail = { PUSH(range) ~ !POP ~ range ~ POP } +checkpoint_restore = ${ + PUSH("") ~ (PUSH("a") ~ "b" ~ POP | DROP ~ "b" | POP ~ "a") ~ EOI +} +ascii_digits = { ASCII_DIGIT+ } +ascii_nonzero_digits = { ASCII_NONZERO_DIGIT+ } +ascii_bin_digits = { ASCII_BIN_DIGIT+ } +ascii_oct_digits = { ASCII_OCT_DIGIT+ } +ascii_hex_digits = { ASCII_HEX_DIGIT+ } +ascii_alpha_lowers = { ASCII_ALPHA_LOWER+ } +ascii_alpha_uppers = { ASCII_ALPHA_UPPER+ } +ascii_alphas = { ASCII_ALPHA+ } +ascii_alphanumerics = { ASCII_ALPHANUMERIC+ } +asciis = { ASCII+ } +newline = { NEWLINE+ } +unicode = { XID_START ~ XID_CONTINUE* } +SYMBOL = { "shadows builtin" } + +WHITESPACE = _{ " " } +COMMENT = _{ "$"+ } + +// Line comment + +/* 1-line multiline comment */ + +/* + N-line multiline comment +*/ + +/* + // Line comment inside multiline + + /* + (Multiline inside) multiline + */ + + Invalid segment of grammar below (repeated rule) + + WHITESPACE = _{ "hi" } +*/ diff --git a/vendor/pest_derive/tests/grammar.rs b/vendor/pest_derive/tests/grammar.rs new file mode 100644 index 000000000..799beb7e0 --- /dev/null +++ b/vendor/pest_derive/tests/grammar.rs @@ -0,0 +1,951 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[macro_use] +extern crate pest; +#[macro_use] +extern crate pest_derive; + +#[derive(Parser)] +#[grammar = "../tests/grammar.pest"] +struct GrammarParser; + +#[test] +fn string() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::string, + tokens: [ + string(0, 3) + ] + }; +} + +#[test] +fn insensitive() { + parses_to! { + parser: GrammarParser, + input: "aBC", + rule: Rule::insensitive, + tokens: [ + insensitive(0, 3) + ] + }; +} + +#[test] +fn range() { + parses_to! { + parser: GrammarParser, + input: "6", + rule: Rule::range, + tokens: [ + range(0, 1) + ] + }; +} + +#[test] +fn ident() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::ident, + tokens: [ + ident(0, 3, [ + string(0, 3) + ]) + ] + }; +} + +#[test] +fn pos_pred() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::pos_pred, + tokens: [ + pos_pred(0, 0) + ] + }; +} + +#[test] +fn neg_pred() { + parses_to! { + parser: GrammarParser, + input: "", + rule: Rule::neg_pred, + tokens: [ + neg_pred(0, 0) + ] + }; +} + +#[test] +fn double_neg_pred() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::double_neg_pred, + tokens: [ + double_neg_pred(0, 0) + ] + }; +} + +#[test] +fn sequence() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::sequence, + tokens: [ + sequence(0, 9, [ + string(0, 3), + string(6, 9) + ]) + ] + }; +} + +#[test] +fn sequence_compound() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::sequence_compound, + tokens: [ + sequence_compound(0, 6, [ + string(0, 3), + string(3, 6) + ]) + ] + }; +} + +#[test] +fn sequence_atomic() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::sequence_atomic, + tokens: [ + sequence_atomic(0, 6) + ] + }; +} + +#[test] +fn sequence_non_atomic() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::sequence_non_atomic, + tokens: [ + sequence_non_atomic(0, 9, [ + sequence(0, 9, [ + string(0, 3), + string(6, 9) + ]) + ]) + ] + }; +} + +#[test] +#[should_panic] +fn sequence_atomic_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::sequence_atomic, + tokens: [] + }; +} + +#[test] +fn sequence_atomic_compound() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::sequence_atomic_compound, + tokens: [ + sequence_atomic_compound(0, 6, [ + sequence_compound(0, 6, [ + string(0, 3), + string(3, 6) + ]) + ]) + ] + }; +} + +#[test] +fn sequence_compound_nested() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::sequence_compound_nested, + tokens: [ + sequence_compound_nested(0, 6, [ + sequence_nested(0, 6, [ + string(0, 3), + string(3, 6) + ]) + ]) + ] + }; +} + +#[test] +#[should_panic] +fn sequence_compound_nested_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::sequence_compound_nested, + tokens: [] + }; +} + +#[test] +fn choice_string() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::choice, + tokens: [ + choice(0, 3, [ + string(0, 3) + ]) + ] + }; +} + +#[test] +fn choice_range() { + parses_to! { + parser: GrammarParser, + input: "0", + rule: Rule::choice, + tokens: [ + choice(0, 1, [ + range(0, 1) + ]) + ] + }; +} + +#[test] +fn optional_string() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::optional, + tokens: [ + optional(0, 3, [ + string(0, 3) + ]) + ] + }; +} + +#[test] +fn optional_empty() { + parses_to! { + parser: GrammarParser, + input: "", + rule: Rule::optional, + tokens: [ + optional(0, 0) + ] + }; +} + +#[test] +fn repeat_empty() { + parses_to! { + parser: GrammarParser, + input: "", + rule: Rule::repeat, + tokens: [ + repeat(0, 0) + ] + }; +} + +#[test] +fn repeat_strings() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat, + tokens: [ + repeat(0, 9, [ + string(0, 3), + string(6, 9) + ]) + ] + }; +} + +#[test] +fn repeat_atomic_empty() { + parses_to! { + parser: GrammarParser, + input: "", + rule: Rule::repeat_atomic, + tokens: [ + repeat_atomic(0, 0) + ] + }; +} + +#[test] +fn repeat_atomic_strings() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::repeat_atomic, + tokens: [ + repeat_atomic(0, 6) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_atomic_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_atomic, + tokens: [] + }; +} + +#[test] +#[should_panic] +fn repeat_once_empty() { + parses_to! { + parser: GrammarParser, + input: "", + rule: Rule::repeat_once, + tokens: [] + }; +} + +#[test] +fn repeat_once_strings() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_once, + tokens: [ + repeat_once(0, 9, [ + string(0, 3), + string(6, 9) + ]) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_once_atomic_empty() { + parses_to! { + parser: GrammarParser, + input: "", + rule: Rule::repeat_once_atomic, + tokens: [] + }; +} + +#[test] +fn repeat_once_atomic_strings() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::repeat_once_atomic, + tokens: [ + repeat_once_atomic(0, 6) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_once_atomic_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_once_atomic, + tokens: [] + }; +} + +#[test] +fn repeat_min_max_twice() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_min_max, + tokens: [ + repeat_min_max(0, 7, [ + string(0, 3), + string(4, 7) + ]) + ] + }; +} + +#[test] +fn repeat_min_max_thrice() { + parses_to! { + parser: GrammarParser, + input: "abc abc abc", + rule: Rule::repeat_min_max, + tokens: [ + repeat_min_max(0, 11, [ + string(0, 3), + string(4, 7), + string(8, 11) + ]) + ] + }; +} + +#[test] +fn repeat_min_max_atomic_twice() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::repeat_min_max_atomic, + tokens: [ + repeat_min_max_atomic(0, 6) + ] + }; +} + +#[test] +fn repeat_min_max_atomic_thrice() { + parses_to! { + parser: GrammarParser, + input: "abcabcabc", + rule: Rule::repeat_min_max_atomic, + tokens: [ + repeat_min_max_atomic(0, 9) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_min_max_atomic_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_min_max_atomic, + tokens: [] + }; +} + +#[test] +fn repeat_exact() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_exact, + tokens: [ + repeat_exact(0, 7, [ + string(0, 3), + string(4, 7) + ]) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_min_once() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::repeat_min, + tokens: [] + }; +} + +#[test] +fn repeat_min_twice() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_min, + tokens: [ + repeat_min(0, 7, [ + string(0, 3), + string(4, 7) + ]) + ] + }; +} + +#[test] +fn repeat_min_thrice() { + parses_to! { + parser: GrammarParser, + input: "abc abc abc", + rule: Rule::repeat_min, + tokens: [ + repeat_min(0, 12, [ + string(0, 3), + string(4, 7), + string(9, 12) + ]) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_min_atomic_once() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::repeat_min_atomic, + tokens: [] + }; +} + +#[test] +fn repeat_min_atomic_twice() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::repeat_min_atomic, + tokens: [ + repeat_min_atomic(0, 6) + ] + }; +} + +#[test] +fn repeat_min_atomic_thrice() { + parses_to! { + parser: GrammarParser, + input: "abcabcabc", + rule: Rule::repeat_min_atomic, + tokens: [ + repeat_min_atomic(0, 9) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_min_atomic_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_min_atomic, + tokens: [] + }; +} + +#[test] +fn repeat_max_once() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::repeat_max, + tokens: [ + repeat_max(0, 3, [ + string(0, 3) + ]) + ] + }; +} + +#[test] +fn repeat_max_twice() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_max, + tokens: [ + repeat_max(0, 7, [ + string(0, 3), + string(4, 7) + ]) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_max_thrice() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_max, + tokens: [] + }; +} + +#[test] +fn repeat_max_atomic_once() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::repeat_max_atomic, + tokens: [ + repeat_max_atomic(0, 3) + ] + }; +} + +#[test] +fn repeat_max_atomic_twice() { + parses_to! { + parser: GrammarParser, + input: "abcabc", + rule: Rule::repeat_max_atomic, + tokens: [ + repeat_max_atomic(0, 6) + ] + }; +} + +#[test] +#[should_panic] +fn repeat_max_atomic_thrice() { + parses_to! { + parser: GrammarParser, + input: "abcabcabc", + rule: Rule::repeat_max_atomic, + tokens: [] + }; +} + +#[test] +#[should_panic] +fn repeat_max_atomic_space() { + parses_to! { + parser: GrammarParser, + input: "abc abc", + rule: Rule::repeat_max_atomic, + tokens: [] + }; +} + +#[test] +fn repeat_comment() { + parses_to! { + parser: GrammarParser, + input: "abc$$$ $$$abc", + rule: Rule::repeat_once, + tokens: [ + repeat_once(0, 13, [ + string(0, 3), + string(10, 13) + ]) + ] + }; +} + +#[test] +fn soi_at_start() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::soi_at_start, + tokens: [ + soi_at_start(0, 3, [ + string(0, 3) + ]) + ] + }; +} + +#[test] +fn peek() { + parses_to! { + parser: GrammarParser, + input: "0111", + rule: Rule::peek_, + tokens: [ + peek_(0, 4, [ + range(0, 1), + range(1, 2) + ]) + ] + }; +} + +#[test] +fn peek_all() { + parses_to! { + parser: GrammarParser, + input: "0110", + rule: Rule::peek_all, + tokens: [ + peek_all(0, 4, [ + range(0, 1), + range(1, 2) + ]) + ] + }; +} + +#[test] +fn peek_slice_23() { + parses_to! { + parser: GrammarParser, + input: "0123412", + rule: Rule::peek_slice_23, + tokens: [ + peek_slice_23(0, 7, [ + range(0, 1), + range(1, 2), + range(2, 3), + range(3, 4), + range(4, 5), + ]) + ] + }; +} + +#[test] +fn pop() { + parses_to! { + parser: GrammarParser, + input: "0110", + rule: Rule::pop_, + tokens: [ + pop_(0, 4, [ + range(0, 1), + range(1, 2) + ]) + ] + }; +} + +#[test] +fn pop_all() { + parses_to! { + parser: GrammarParser, + input: "0110", + rule: Rule::pop_all, + tokens: [ + pop_all(0, 4, [ + range(0, 1), + range(1, 2) + ]) + ] + }; +} + +#[test] +fn pop_fail() { + parses_to! { + parser: GrammarParser, + input: "010", + rule: Rule::pop_fail, + tokens: [ + pop_fail(0, 3, [ + range(0, 1), + range(1, 2) + ]) + ] + }; +} + +#[test] +fn repeat_mutate_stack() { + parses_to! { + parser: GrammarParser, + input: "a,b,c,cba", + rule: Rule::repeat_mutate_stack, + tokens: [ + repeat_mutate_stack(0, 9) + ] + }; +} + +#[test] +fn checkpoint_restore() { + parses_to! { + parser: GrammarParser, + input: "a", + rule: Rule::checkpoint_restore, + tokens: [ + checkpoint_restore(0, 1, [EOI(1, 1)]) + ] + }; +} + +#[test] +fn ascii_digits() { + parses_to! { + parser: GrammarParser, + input: "6", + rule: Rule::ascii_digits, + tokens: [ + ascii_digits(0, 1) + ] + }; +} + +#[test] +fn ascii_nonzero_digits() { + parses_to! { + parser: GrammarParser, + input: "5", + rule: Rule::ascii_nonzero_digits, + tokens: [ + ascii_nonzero_digits(0, 1) + ] + }; +} + +#[test] +fn ascii_bin_digits() { + parses_to! { + parser: GrammarParser, + input: "1", + rule: Rule::ascii_bin_digits, + tokens: [ + ascii_bin_digits(0, 1) + ] + }; +} + +#[test] +fn ascii_oct_digits() { + parses_to! { + parser: GrammarParser, + input: "3", + rule: Rule::ascii_oct_digits, + tokens: [ + ascii_oct_digits(0, 1) + ] + }; +} + +#[test] +fn ascii_hex_digits() { + parses_to! { + parser: GrammarParser, + input: "6bC", + rule: Rule::ascii_hex_digits, + tokens: [ + ascii_hex_digits(0, 3) + ] + }; +} + +#[test] +fn ascii_alpha_lowers() { + parses_to! { + parser: GrammarParser, + input: "a", + rule: Rule::ascii_alpha_lowers, + tokens: [ + ascii_alpha_lowers(0, 1) + ] + }; +} + +#[test] +fn ascii_alpha_uppers() { + parses_to! { + parser: GrammarParser, + input: "K", + rule: Rule::ascii_alpha_uppers, + tokens: [ + ascii_alpha_uppers(0, 1) + ] + }; +} + +#[test] +fn ascii_alphas() { + parses_to! { + parser: GrammarParser, + input: "wF", + rule: Rule::ascii_alphas, + tokens: [ + ascii_alphas(0, 2) + ] + }; +} + +#[test] +fn ascii_alphanumerics() { + parses_to! { + parser: GrammarParser, + input: "4jU", + rule: Rule::ascii_alphanumerics, + tokens: [ + ascii_alphanumerics(0, 3) + ] + }; +} + +#[test] +fn asciis() { + parses_to! { + parser: GrammarParser, + input: "x02", + rule: Rule::asciis, + tokens: [ + asciis(0, 3) + ] + }; +} + +#[test] +fn newline() { + parses_to! { + parser: GrammarParser, + input: "\n\r\n\r", + rule: Rule::newline, + tokens: [ + newline(0, 4) + ] + }; +} + +#[test] +fn unicode() { + parses_to! { + parser: GrammarParser, + input: "نامهای", + rule: Rule::unicode, + tokens: [ + unicode(0, 12) + ] + } +} + +#[test] +fn shadowing() { + parses_to! { + parser: GrammarParser, + input: "shadows builtin", + rule: Rule::SYMBOL, + tokens: [ + SYMBOL(0, 15) + ] + } +} diff --git a/vendor/pest_derive/tests/grammar_inline.rs b/vendor/pest_derive/tests/grammar_inline.rs new file mode 100644 index 000000000..2cc730afc --- /dev/null +++ b/vendor/pest_derive/tests/grammar_inline.rs @@ -0,0 +1,26 @@ +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[macro_use] +extern crate pest; +#[macro_use] +extern crate pest_derive; + +#[derive(Parser)] +#[grammar_inline = "string = { \"abc\" }"] +struct GrammarParser; + +#[test] +fn inline_string() { + parses_to! { + parser: GrammarParser, + input: "abc", + rule: Rule::string, + tokens: [ + string(0, 3) + ] + }; +} diff --git a/vendor/pest_derive/tests/lists.pest b/vendor/pest_derive/tests/lists.pest new file mode 100644 index 000000000..47756b764 --- /dev/null +++ b/vendor/pest_derive/tests/lists.pest @@ -0,0 +1,18 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +item = { (!"\n" ~ ANY)* } + +lists = _{ lines ~ EOI } +lines = _{ top_first ~ ("\n" ~ top_continue)* } +top_first = _{ "- " ~ item ~ ("\n" ~ children)? } +top_continue = _{ PEEK_ALL ~ "- " ~ item ~ ("\n" ~ children)? } + +indentation = _{ (" " | "\t")+ } +children = { PEEK_ALL ~ PUSH(indentation) ~ lines ~ DROP } diff --git a/vendor/pest_derive/tests/lists.rs b/vendor/pest_derive/tests/lists.rs new file mode 100644 index 000000000..4ba0effce --- /dev/null +++ b/vendor/pest_derive/tests/lists.rs @@ -0,0 +1,121 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[macro_use] +extern crate pest; +#[macro_use] +extern crate pest_derive; + +#[derive(Parser)] +#[grammar = "../tests/lists.pest"] +struct ListsParser; + +#[test] +fn item() { + parses_to! { + parser: ListsParser, + input: "- a", + rule: Rule::lists, + tokens: [ + item(2, 3) + ] + }; +} + +#[test] +fn items() { + parses_to! { + parser: ListsParser, + input: "- a\n- b", + rule: Rule::lists, + tokens: [ + item(2, 3), + item(6, 7) + ] + }; +} + +#[test] +fn children() { + parses_to! { + parser: ListsParser, + input: " - b", + rule: Rule::children, + tokens: [ + children(0, 5, [ + item(4, 5) + ]) + ] + }; +} + +#[test] +fn nested_item() { + parses_to! { + parser: ListsParser, + input: "- a\n - b", + rule: Rule::lists, + tokens: [ + item(2, 3), + children(4, 9, [ + item(8, 9) + ]) + ] + }; +} + +#[test] +fn nested_items() { + parses_to! { + parser: ListsParser, + input: "- a\n - b\n - c", + rule: Rule::lists, + tokens: [ + item(2, 3), + children(4, 15, [ + item(8, 9), + item(14, 15) + ]) + ] + }; +} + +#[test] +fn nested_two_levels() { + parses_to! { + parser: ListsParser, + input: "- a\n - b\n - c", + rule: Rule::lists, + tokens: [ + item(2, 3), + children(4, 17, [ + item(8, 9), + children(10, 17, [ + item(16, 17) + ]) + ]) + ] + }; +} + +#[test] +fn nested_then_not() { + parses_to! { + parser: ListsParser, + input: "- a\n - b\n- c", + rule: Rule::lists, + tokens: [ + item(2, 3), + children(4, 9, [ + item(8, 9) + ]), + item(12, 13) + ] + }; +} diff --git a/vendor/pest_derive/tests/reporting.pest b/vendor/pest_derive/tests/reporting.pest new file mode 100644 index 000000000..060dbfc20 --- /dev/null +++ b/vendor/pest_derive/tests/reporting.pest @@ -0,0 +1,27 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +a = { "a" } +b = { "b" } +c = { "c" } +d = { ANY } + +choices = _{ a | b | c } +choices_no_progress = { a | b | c } +choices_a_progress = { a ~ a | b | c } +choices_b_progress = { a | b ~ b | c } + +level1 = _{ level2 } +level2 = _{ a | b | c } + +negative = _{ !d } +negative_match = _{ !a ~ b } +mixed = _{ !d | a } +mixed_progress = _{ (!d | a | b) ~ a } + diff --git a/vendor/pest_derive/tests/reporting.rs b/vendor/pest_derive/tests/reporting.rs new file mode 100644 index 000000000..aa0a974e0 --- /dev/null +++ b/vendor/pest_derive/tests/reporting.rs @@ -0,0 +1,125 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[macro_use] +extern crate pest; +#[macro_use] +extern crate pest_derive; + +#[derive(Parser)] +#[grammar = "../tests/reporting.pest"] +struct ReportingParser; + +#[test] +fn choices() { + fails_with! { + parser: ReportingParser, + input: "x", + rule: Rule::choices, + positives: vec![Rule::a, Rule::b, Rule::c], + negatives: vec![], + pos: 0 + }; +} + +#[test] +fn choices_no_progress() { + fails_with! { + parser: ReportingParser, + input: "x", + rule: Rule::choices_no_progress, + positives: vec![Rule::choices_no_progress], + negatives: vec![], + pos: 0 + }; +} + +#[test] +fn choices_a_progress() { + fails_with! { + parser: ReportingParser, + input: "a", + rule: Rule::choices_a_progress, + positives: vec![Rule::a], + negatives: vec![], + pos: 1 + }; +} + +#[test] +fn choices_b_progress() { + fails_with! { + parser: ReportingParser, + input: "b", + rule: Rule::choices_b_progress, + positives: vec![Rule::b], + negatives: vec![], + pos: 1 + }; +} + +#[test] +fn nested() { + fails_with! { + parser: ReportingParser, + input: "x", + rule: Rule::level1, + positives: vec![Rule::a, Rule::b, Rule::c], + negatives: vec![], + pos: 0 + }; +} + +#[test] +fn negative() { + fails_with! { + parser: ReportingParser, + input: "x", + rule: Rule::negative, + positives: vec![], + negatives: vec![Rule::d], + pos: 0 + }; +} + +#[test] +fn negative_match() { + fails_with! { + parser: ReportingParser, + input: "x", + rule: Rule::negative_match, + positives: vec![Rule::b], + negatives: vec![], + pos: 0 + }; +} + +#[test] +fn mixed() { + fails_with! { + parser: ReportingParser, + input: "x", + rule: Rule::mixed, + positives: vec![Rule::a], + negatives: vec![Rule::d], + pos: 0 + }; +} + +#[test] +fn mixed_progress() { + fails_with! { + parser: ReportingParser, + input: "b", + rule: Rule::mixed_progress, + positives: vec![Rule::a], + negatives: vec![], + pos: 1 + }; +} diff --git a/vendor/pest_generator/.cargo-checksum.json b/vendor/pest_generator/.cargo-checksum.json new file mode 100644 index 000000000..54f869f8e --- /dev/null +++ b/vendor/pest_generator/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"0f2f8b8f880c20e4281e53b2675356ee672d7c04b015f4c182509ed2ca614e6e","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","_README.md":"e9901b6c4d50403bfda7e08a92b5c395a8c51eba868c7bd07b03e00ccba702f3","src/generator.rs":"7b0b67ec000ccde0ec8df83b26f84e0a7b2a17e255e900ab28379984e7dbba27","src/lib.rs":"1cc63047aad721587a23eeea54d4c398bf5c085d934e41100a8766954a1b6071","src/macros.rs":"03ae0a9ec0210b19c8e6becc275df11b504003d22f3ff758d8bf3ee997d2b476"},"package":"99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"}
\ No newline at end of file diff --git a/vendor/pest_generator/Cargo.toml b/vendor/pest_generator/Cargo.toml new file mode 100644 index 000000000..1ef45f99a --- /dev/null +++ b/vendor/pest_generator/Cargo.toml @@ -0,0 +1,46 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "pest_generator" +version = "2.1.3" +authors = ["Dragoș Tiselice <dragostiselice@gmail.com>"] +description = "pest code generator" +homepage = "https://pest-parser.github.io/" +documentation = "https://docs.rs/pest" +readme = "_README.md" +keywords = ["pest", "generator"] +categories = ["parsing"] +license = "MIT/Apache-2.0" +repository = "https://github.com/pest-parser/pest" +[dependencies.pest] +version = "2.1.0" + +[dependencies.pest_meta] +version = "2.1.0" + +[dependencies.proc-macro2] +version = "1.0" + +[dependencies.quote] +version = "1.0" + +[dependencies.syn] +version = "1.0" +[badges.codecov] +repository = "pest-parser/pest" + +[badges.maintenance] +status = "actively-developed" + +[badges.travis-ci] +repository = "pest-parser/pest" diff --git a/vendor/pest_generator/LICENSE-APACHE b/vendor/pest_generator/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/vendor/pest_generator/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/pest_generator/LICENSE-MIT b/vendor/pest_generator/LICENSE-MIT new file mode 100644 index 000000000..31aa79387 --- /dev/null +++ b/vendor/pest_generator/LICENSE-MIT @@ -0,0 +1,23 @@ +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/pest_generator/_README.md b/vendor/pest_generator/_README.md new file mode 100644 index 000000000..8e55f29a2 --- /dev/null +++ b/vendor/pest_generator/_README.md @@ -0,0 +1,169 @@ +<p align="center"> + <img src="https://raw.github.com/pest-parser/pest/master/pest-logo.svg?sanitize=true" width="80%"/> +</p> + +# pest. The Elegant Parser + +[![Join the chat at https://gitter.im/dragostis/pest](https://badges.gitter.im/dragostis/pest.svg)](https://gitter.im/dragostis/pest?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[![Book](https://img.shields.io/badge/book-WIP-4d76ae.svg)](https://pest-parser.github.io/book) +[![Docs](https://docs.rs/pest/badge.svg)](https://docs.rs/pest) + +[![Build Status](https://travis-ci.org/pest-parser/pest.svg?branch=master)](https://travis-ci.org/pest-parser/pest) +[![codecov](https://codecov.io/gh/pest-parser/pest/branch/master/graph/badge.svg)](https://codecov.io/gh/pest-parser/pest) +[![Fuzzit Status](https://app.fuzzit.dev/badge?org_id=pest-parser)](https://app.fuzzit.dev/orgs/pest-parser/dashboard) +[![Crates.io](https://img.shields.io/crates/d/pest.svg)](https://crates.io/crates/pest) +[![Crates.io](https://img.shields.io/crates/v/pest.svg)](https://crates.io/crates/pest) + +pest is a general purpose parser written in Rust with a focus on accessibility, +correctness, and performance. It uses parsing expression grammars +(or [PEG]) as input, which are similar in spirit to regular expressions, but +which offer the enhanced expressivity needed to parse complex languages. + +[PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar + +## Getting started + +The recommended way to start parsing with pest is to read the official [book]. + +Other helpful resources: + +* API reference on [docs.rs] +* play with grammars and share them on our [fiddle] +* leave feedback, ask questions, or greet us on [Gitter] + +[book]: https://pest-parser.github.io/book +[docs.rs]: https://docs.rs/pest +[fiddle]: https://pest-parser.github.io/#editor +[Gitter]: https://gitter.im/dragostis/pest + +## Example + +The following is an example of a grammar for a list of alpha-numeric identifiers +where the first identifier does not start with a digit: + +```rust +alpha = { 'a'..'z' | 'A'..'Z' } +digit = { '0'..'9' } + +ident = { (alpha | digit)+ } + +ident_list = _{ !digit ~ ident ~ (" " ~ ident)+ } + // ^ + // ident_list rule is silent which means it produces no tokens +``` + +Grammars are saved in separate .pest files which are never mixed with procedural +code. This results in an always up-to-date formalization of a language that is +easy to read and maintain. + +## Meaningful error reporting + +Based on the grammar definition, the parser also includes automatic error +reporting. For the example above, the input `"123"` will result in: + +``` +thread 'main' panicked at ' --> 1:1 + | +1 | 123 + | ^--- + | + = unexpected digit', src/main.rs:12 +``` +while `"ab *"` will result in: +``` +thread 'main' panicked at ' --> 1:1 + | +1 | ab * + | ^--- + | + = expected ident', src/main.rs:12 +``` + +## Pairs API + +The grammar can be used to derive a `Parser` implementation automatically. +Parsing returns an iterator of nested token pairs: + +```rust +extern crate pest; +#[macro_use] +extern crate pest_derive; + +use pest::Parser; + +#[derive(Parser)] +#[grammar = "ident.pest"] +struct IdentParser; + +fn main() { + let pairs = IdentParser::parse(Rule::ident_list, "a1 b2").unwrap_or_else(|e| panic!("{}", e)); + + // Because ident_list is silent, the iterator will contain idents + for pair in pairs { + // A pair is a combination of the rule which matched and a span of input + println!("Rule: {:?}", pair.as_rule()); + println!("Span: {:?}", pair.as_span()); + println!("Text: {}", pair.as_str()); + + // A pair can be converted to an iterator of the tokens which make it up: + for inner_pair in pair.into_inner() { + match inner_pair.as_rule() { + Rule::alpha => println!("Letter: {}", inner_pair.as_str()), + Rule::digit => println!("Digit: {}", inner_pair.as_str()), + _ => unreachable!() + }; + } + } +} +``` + +This produces the following output: +``` +Rule: ident +Span: Span { start: 0, end: 2 } +Text: a1 +Letter: a +Digit: 1 +Rule: ident +Span: Span { start: 3, end: 5 } +Text: b2 +Letter: b +Digit: 2 +``` + +## Other features + +* Precedence climbing +* Input handling +* Custom errors +* Runs on stable Rust + +## Projects using pest + +* [pest_meta](https://github.com/pest-parser/pest/blob/master/meta/src/grammar.pest) (bootstrapped) +* [AshPaper](https://github.com/shnewto/ashpaper) +* [brain](https://github.com/brain-lang/brain) +* [Chelone](https://github.com/Aaronepower/chelone) +* [comrak](https://github.com/kivikakk/comrak) +* [elastic-rs](https://github.com/cch123/elastic-rs) +* [graphql-parser](https://github.com/Keats/graphql-parser) +* [handlebars-rust](https://github.com/sunng87/handlebars-rust) +* [hexdino](https://github.com/Luz/hexdino) +* [Huia](https://gitlab.com/jimsy/huia/) +* [jql](https://github.com/yamafaktory/jql) +* [json5-rs](https://github.com/callum-oakley/json5-rs) +* [mt940](https://github.com/svenstaro/mt940-rs) +* [py_literal](https://github.com/jturner314/py_literal) +* [rouler](https://github.com/jarcane/rouler) +* [RuSh](https://github.com/lwandrebeck/RuSh) +* [rs_pbrt](https://github.com/wahn/rs_pbrt) +* [stache](https://github.com/dgraham/stache) +* [tera](https://github.com/Keats/tera) +* [ui_gen](https://github.com/emoon/ui_gen) +* [ukhasnet-parser](https://github.com/adamgreig/ukhasnet-parser) +* [ZoKrates](https://github.com/ZoKrates/ZoKrates) + +## Special thanks + +A special round of applause goes to prof. Marius Minea for his guidance and all +pest contributors, some of which being none other than my friends. diff --git a/vendor/pest_generator/src/generator.rs b/vendor/pest_generator/src/generator.rs new file mode 100644 index 000000000..bed56f34a --- /dev/null +++ b/vendor/pest_generator/src/generator.rs @@ -0,0 +1,1002 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::path::PathBuf; + +use proc_macro2::{Span, TokenStream}; +use quote::{ToTokens, TokenStreamExt}; +use syn::{self, Generics, Ident}; + +use pest_meta::ast::*; +use pest_meta::optimizer::*; +use pest_meta::UNICODE_PROPERTY_NAMES; + +#[allow(clippy::needless_pass_by_value)] +pub fn generate( + name: Ident, + generics: &Generics, + path: Option<PathBuf>, + rules: Vec<OptimizedRule>, + defaults: Vec<&str>, + include_grammar: bool, +) -> TokenStream { + let uses_eoi = defaults.iter().any(|name| *name == "EOI"); + + let builtins = generate_builtin_rules(); + let include_fix = if include_grammar { + match path { + Some(ref path) => generate_include(&name, path.to_str().expect("non-Unicode path")), + None => quote!(), + } + } else { + quote!() + }; + let rule_enum = generate_enum(&rules, uses_eoi); + let patterns = generate_patterns(&rules, uses_eoi); + let skip = generate_skip(&rules); + + let mut rules: Vec<_> = rules.into_iter().map(generate_rule).collect(); + rules.extend(builtins.into_iter().filter_map(|(builtin, tokens)| { + if defaults.contains(&builtin) { + Some(tokens) + } else { + None + } + })); + + let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); + + let parser_impl = quote! { + #[allow(clippy::all)] + impl #impl_generics ::pest::Parser<Rule> for #name #ty_generics #where_clause { + fn parse<'i>( + rule: Rule, + input: &'i str + ) -> ::std::result::Result< + ::pest::iterators::Pairs<'i, Rule>, + ::pest::error::Error<Rule> + > { + mod rules { + pub mod hidden { + use super::super::Rule; + #skip + } + + pub mod visible { + use super::super::Rule; + #( #rules )* + } + + pub use self::visible::*; + } + + ::pest::state(input, |state| { + match rule { + #patterns + } + }) + } + } + }; + + quote! { + #include_fix + #rule_enum + #parser_impl + } +} + +// Note: All builtin rules should be validated as pest builtins in meta/src/validator.rs. +// Some should also be keywords. +fn generate_builtin_rules() -> Vec<(&'static str, TokenStream)> { + let mut builtins = Vec::new(); + + insert_builtin!(builtins, ANY, state.skip(1)); + insert_public_builtin!( + builtins, + EOI, + state.rule(Rule::EOI, |state| state.end_of_input()) + ); + insert_builtin!(builtins, SOI, state.start_of_input()); + insert_builtin!(builtins, PEEK, state.stack_peek()); + insert_builtin!(builtins, PEEK_ALL, state.stack_match_peek()); + insert_builtin!(builtins, POP, state.stack_pop()); + insert_builtin!(builtins, POP_ALL, state.stack_match_pop()); + insert_builtin!(builtins, DROP, state.stack_drop()); + + insert_builtin!(builtins, ASCII_DIGIT, state.match_range('0'..'9')); + insert_builtin!(builtins, ASCII_NONZERO_DIGIT, state.match_range('1'..'9')); + insert_builtin!(builtins, ASCII_BIN_DIGIT, state.match_range('0'..'1')); + insert_builtin!(builtins, ASCII_OCT_DIGIT, state.match_range('0'..'7')); + insert_builtin!( + builtins, + ASCII_HEX_DIGIT, + state + .match_range('0'..'9') + .or_else(|state| state.match_range('a'..'f')) + .or_else(|state| state.match_range('A'..'F')) + ); + insert_builtin!(builtins, ASCII_ALPHA_LOWER, state.match_range('a'..'z')); + insert_builtin!(builtins, ASCII_ALPHA_UPPER, state.match_range('A'..'Z')); + insert_builtin!( + builtins, + ASCII_ALPHA, + state + .match_range('a'..'z') + .or_else(|state| state.match_range('A'..'Z')) + ); + insert_builtin!( + builtins, + ASCII_ALPHANUMERIC, + state + .match_range('a'..'z') + .or_else(|state| state.match_range('A'..'Z')) + .or_else(|state| state.match_range('0'..'9')) + ); + insert_builtin!(builtins, ASCII, state.match_range('\x00'..'\x7f')); + insert_builtin!( + builtins, + NEWLINE, + state + .match_string("\n") + .or_else(|state| state.match_string("\r\n")) + .or_else(|state| state.match_string("\r")) + ); + + for property in UNICODE_PROPERTY_NAMES { + let property_ident: Ident = syn::parse_str(property).unwrap(); + // insert manually for #property substitution + builtins.push((property, quote! { + #[inline] + #[allow(dead_code, non_snake_case, unused_variables)] + fn #property_ident(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.match_char_by(::pest::unicode::#property_ident) + } + })); + } + builtins +} + +// Needed because Cargo doesn't watch for changes in grammars. +fn generate_include(name: &Ident, path: &str) -> TokenStream { + let const_name = Ident::new(&format!("_PEST_GRAMMAR_{}", name), Span::call_site()); + // Need to make this relative to the current directory since the path to the file + // is derived from the CARGO_MANIFEST_DIR environment variable + let mut current_dir = std::env::current_dir().expect("Unable to get current directory"); + current_dir.push(path); + let relative_path = current_dir.to_str().expect("path contains invalid unicode"); + quote! { + #[allow(non_upper_case_globals)] + const #const_name: &'static str = include_str!(#relative_path); + } +} + +fn generate_enum(rules: &[OptimizedRule], uses_eoi: bool) -> TokenStream { + let rules = rules + .iter() + .map(|rule| Ident::new(rule.name.as_str(), Span::call_site())); + if uses_eoi { + quote! { + #[allow(dead_code, non_camel_case_types)] + #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub enum Rule { + EOI, + #( #rules ),* + } + } + } else { + quote! { + #[allow(dead_code, non_camel_case_types)] + #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub enum Rule { + #( #rules ),* + } + } + } +} + +fn generate_patterns(rules: &[OptimizedRule], uses_eoi: bool) -> TokenStream { + let mut rules: Vec<TokenStream> = rules + .iter() + .map(|rule| { + let rule = Ident::new(rule.name.as_str(), Span::call_site()); + quote! { + Rule::#rule => rules::#rule(state) + } + }) + .collect(); + + if uses_eoi { + rules.push(quote! { + Rule::EOI => rules::EOI(state) + }); + } + + quote! { + #( #rules ),* + } +} + +fn generate_rule(rule: OptimizedRule) -> TokenStream { + let name = Ident::new(&rule.name, Span::call_site()); + let expr = if rule.ty == RuleType::Atomic || rule.ty == RuleType::CompoundAtomic { + generate_expr_atomic(rule.expr) + } else if name == "WHITESPACE" || name == "COMMENT" { + let atomic = generate_expr_atomic(rule.expr); + + quote! { + state.atomic(::pest::Atomicity::Atomic, |state| { + #atomic + }) + } + } else { + generate_expr(rule.expr) + }; + + match rule.ty { + RuleType::Normal => quote! { + #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.rule(Rule::#name, |state| { + #expr + }) + } + }, + RuleType::Silent => quote! { + #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + #expr + } + }, + RuleType::Atomic => quote! { + #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.rule(Rule::#name, |state| { + state.atomic(::pest::Atomicity::Atomic, |state| { + #expr + }) + }) + } + }, + RuleType::CompoundAtomic => quote! { + #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.atomic(::pest::Atomicity::CompoundAtomic, |state| { + state.rule(Rule::#name, |state| { + #expr + }) + }) + } + }, + RuleType::NonAtomic => quote! { + #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn #name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.atomic(::pest::Atomicity::NonAtomic, |state| { + state.rule(Rule::#name, |state| { + #expr + }) + }) + } + }, + } +} + +fn generate_skip(rules: &[OptimizedRule]) -> TokenStream { + let whitespace = rules.iter().any(|rule| rule.name == "WHITESPACE"); + let comment = rules.iter().any(|rule| rule.name == "COMMENT"); + + match (whitespace, comment) { + (false, false) => generate_rule!(skip, Ok(state)), + (true, false) => generate_rule!( + skip, + if state.atomicity() == ::pest::Atomicity::NonAtomic { + state.repeat(|state| super::visible::WHITESPACE(state)) + } else { + Ok(state) + } + ), + (false, true) => generate_rule!( + skip, + if state.atomicity() == ::pest::Atomicity::NonAtomic { + state.repeat(|state| super::visible::COMMENT(state)) + } else { + Ok(state) + } + ), + (true, true) => generate_rule!( + skip, + if state.atomicity() == ::pest::Atomicity::NonAtomic { + state.sequence(|state| { + state + .repeat(|state| super::visible::WHITESPACE(state)) + .and_then(|state| { + state.repeat(|state| { + state.sequence(|state| { + super::visible::COMMENT(state).and_then(|state| { + state.repeat(|state| super::visible::WHITESPACE(state)) + }) + }) + }) + }) + }) + } else { + Ok(state) + } + ), + } +} + +fn generate_expr(expr: OptimizedExpr) -> TokenStream { + match expr { + OptimizedExpr::Str(string) => { + quote! { + state.match_string(#string) + } + } + OptimizedExpr::Insens(string) => { + quote! { + state.match_insensitive(#string) + } + } + OptimizedExpr::Range(start, end) => { + let start = start.chars().next().unwrap(); + let end = end.chars().next().unwrap(); + + quote! { + state.match_range(#start..#end) + } + } + OptimizedExpr::Ident(ident) => { + let ident = Ident::new(&ident, Span::call_site()); + quote! { self::#ident(state) } + } + OptimizedExpr::PeekSlice(start, end_) => { + let end = QuoteOption(end_); + quote! { + state.stack_match_peek_slice(#start, #end, ::pest::MatchDir::BottomToTop) + } + } + OptimizedExpr::PosPred(expr) => { + let expr = generate_expr(*expr); + + quote! { + state.lookahead(true, |state| { + #expr + }) + } + } + OptimizedExpr::NegPred(expr) => { + let expr = generate_expr(*expr); + + quote! { + state.lookahead(false, |state| { + #expr + }) + } + } + OptimizedExpr::Seq(lhs, rhs) => { + let head = generate_expr(*lhs); + let mut tail = vec![]; + let mut current = *rhs; + + while let OptimizedExpr::Seq(lhs, rhs) = current { + tail.push(generate_expr(*lhs)); + current = *rhs; + } + tail.push(generate_expr(current)); + + quote! { + state.sequence(|state| { + #head + #( + .and_then(|state| { + super::hidden::skip(state) + }).and_then(|state| { + #tail + }) + )* + }) + } + } + OptimizedExpr::Choice(lhs, rhs) => { + let head = generate_expr(*lhs); + let mut tail = vec![]; + let mut current = *rhs; + + while let OptimizedExpr::Choice(lhs, rhs) = current { + tail.push(generate_expr(*lhs)); + current = *rhs; + } + tail.push(generate_expr(current)); + + quote! { + #head + #( + .or_else(|state| { + #tail + }) + )* + } + } + OptimizedExpr::Opt(expr) => { + let expr = generate_expr(*expr); + + quote! { + state.optional(|state| { + #expr + }) + } + } + OptimizedExpr::Rep(expr) => { + let expr = generate_expr(*expr); + + quote! { + state.sequence(|state| { + state.optional(|state| { + #expr.and_then(|state| { + state.repeat(|state| { + state.sequence(|state| { + super::hidden::skip( + state + ).and_then(|state| { + #expr + }) + }) + }) + }) + }) + }) + } + } + OptimizedExpr::Skip(strings) => { + quote! { + let strings = [#(#strings),*]; + + state.skip_until(&strings) + } + } + OptimizedExpr::Push(expr) => { + let expr = generate_expr(*expr); + + quote! { + state.stack_push(|state| #expr) + } + } + OptimizedExpr::RestoreOnErr(expr) => { + let expr = generate_expr(*expr); + + quote! { + state.restore_on_err(|state| #expr) + } + } + } +} + +fn generate_expr_atomic(expr: OptimizedExpr) -> TokenStream { + match expr { + OptimizedExpr::Str(string) => { + quote! { + state.match_string(#string) + } + } + OptimizedExpr::Insens(string) => { + quote! { + state.match_insensitive(#string) + } + } + OptimizedExpr::Range(start, end) => { + let start = start.chars().next().unwrap(); + let end = end.chars().next().unwrap(); + + quote! { + state.match_range(#start..#end) + } + } + OptimizedExpr::Ident(ident) => { + let ident = Ident::new(&ident, Span::call_site()); + quote! { self::#ident(state) } + } + OptimizedExpr::PeekSlice(start, end_) => { + let end = QuoteOption(end_); + quote! { + state.stack_match_peek_slice(#start, #end, ::pest::MatchDir::BottomToTop) + } + } + OptimizedExpr::PosPred(expr) => { + let expr = generate_expr_atomic(*expr); + + quote! { + state.lookahead(true, |state| { + #expr + }) + } + } + OptimizedExpr::NegPred(expr) => { + let expr = generate_expr_atomic(*expr); + + quote! { + state.lookahead(false, |state| { + #expr + }) + } + } + OptimizedExpr::Seq(lhs, rhs) => { + let head = generate_expr_atomic(*lhs); + let mut tail = vec![]; + let mut current = *rhs; + + while let OptimizedExpr::Seq(lhs, rhs) = current { + tail.push(generate_expr_atomic(*lhs)); + current = *rhs; + } + tail.push(generate_expr_atomic(current)); + + quote! { + state.sequence(|state| { + #head + #( + .and_then(|state| { + #tail + }) + )* + }) + } + } + OptimizedExpr::Choice(lhs, rhs) => { + let head = generate_expr_atomic(*lhs); + let mut tail = vec![]; + let mut current = *rhs; + + while let OptimizedExpr::Choice(lhs, rhs) = current { + tail.push(generate_expr_atomic(*lhs)); + current = *rhs; + } + tail.push(generate_expr_atomic(current)); + + quote! { + #head + #( + .or_else(|state| { + #tail + }) + )* + } + } + OptimizedExpr::Opt(expr) => { + let expr = generate_expr_atomic(*expr); + + quote! { + state.optional(|state| { + #expr + }) + } + } + OptimizedExpr::Rep(expr) => { + let expr = generate_expr_atomic(*expr); + + quote! { + state.repeat(|state| { + #expr + }) + } + } + OptimizedExpr::Skip(strings) => { + quote! { + let strings = [#(#strings),*]; + + state.skip_until(&strings) + } + } + OptimizedExpr::Push(expr) => { + let expr = generate_expr_atomic(*expr); + + quote! { + state.stack_push(|state| #expr) + } + } + OptimizedExpr::RestoreOnErr(expr) => { + let expr = generate_expr_atomic(*expr); + + quote! { + state.restore_on_err(|state| #expr) + } + } + } +} + +struct QuoteOption<T>(Option<T>); + +impl<T: ToTokens> ToTokens for QuoteOption<T> { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(match self.0 { + Some(ref t) => quote! { ::std::option::Option::Some(#t) }, + None => quote! { ::std::option::Option::None }, + }); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rule_enum_simple() { + let rules = vec![OptimizedRule { + name: "f".to_owned(), + ty: RuleType::Normal, + expr: OptimizedExpr::Ident("g".to_owned()), + }]; + + assert_eq!( + generate_enum(&rules, false).to_string(), + quote! { + #[allow(dead_code, non_camel_case_types)] + #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub enum Rule { + f + } + } + .to_string() + ); + } + + #[test] + fn sequence() { + let expr = OptimizedExpr::Seq( + Box::new(OptimizedExpr::Str("a".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::Str("b".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::Str("c".to_owned())), + Box::new(OptimizedExpr::Str("d".to_owned())), + )), + )), + ); + + assert_eq!( + generate_expr(expr).to_string(), + quote! { + state.sequence(|state| { + state.match_string("a").and_then(|state| { + super::hidden::skip(state) + }).and_then(|state| { + state.match_string("b") + }).and_then(|state| { + super::hidden::skip(state) + }).and_then(|state| { + state.match_string("c") + }).and_then(|state| { + super::hidden::skip(state) + }).and_then(|state| { + state.match_string("d") + }) + }) + } + .to_string() + ); + } + + #[test] + fn sequence_atomic() { + let expr = OptimizedExpr::Seq( + Box::new(OptimizedExpr::Str("a".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::Str("b".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::Str("c".to_owned())), + Box::new(OptimizedExpr::Str("d".to_owned())), + )), + )), + ); + + assert_eq!( + generate_expr_atomic(expr).to_string(), + quote! { + state.sequence(|state| { + state.match_string("a").and_then(|state| { + state.match_string("b") + }).and_then(|state| { + state.match_string("c") + }).and_then(|state| { + state.match_string("d") + }) + }) + } + .to_string() + ); + } + + #[test] + fn choice() { + let expr = OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("a".to_owned())), + Box::new(OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("b".to_owned())), + Box::new(OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("c".to_owned())), + Box::new(OptimizedExpr::Str("d".to_owned())), + )), + )), + ); + + assert_eq!( + generate_expr(expr).to_string(), + quote! { + state.match_string("a").or_else(|state| { + state.match_string("b") + }).or_else(|state| { + state.match_string("c") + }).or_else(|state| { + state.match_string("d") + }) + } + .to_string() + ); + } + + #[test] + fn choice_atomic() { + let expr = OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("a".to_owned())), + Box::new(OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("b".to_owned())), + Box::new(OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("c".to_owned())), + Box::new(OptimizedExpr::Str("d".to_owned())), + )), + )), + ); + + assert_eq!( + generate_expr_atomic(expr).to_string(), + quote! { + state.match_string("a").or_else(|state| { + state.match_string("b") + }).or_else(|state| { + state.match_string("c") + }).or_else(|state| { + state.match_string("d") + }) + } + .to_string() + ); + } + + #[test] + fn skip() { + let expr = OptimizedExpr::Skip(vec!["a".to_owned(), "b".to_owned()]); + + assert_eq!( + generate_expr_atomic(expr).to_string(), + quote! { + let strings = ["a", "b"]; + + state.skip_until(&strings) + } + .to_string() + ); + } + + #[test] + fn expr_complex() { + let expr = OptimizedExpr::Choice( + Box::new(OptimizedExpr::Ident("a".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::Range("a".to_owned(), "b".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::NegPred(Box::new(OptimizedExpr::Rep( + Box::new(OptimizedExpr::Insens("b".to_owned())), + )))), + Box::new(OptimizedExpr::PosPred(Box::new(OptimizedExpr::Opt( + Box::new(OptimizedExpr::Rep(Box::new(OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("c".to_owned())), + Box::new(OptimizedExpr::Str("d".to_owned())), + )))), + )))), + )), + )), + ); + + let sequence = quote! { + state.sequence(|state| { + super::hidden::skip(state).and_then( + |state| { + state.match_insensitive("b") + } + ) + }) + }; + let repeat = quote! { + state.repeat(|state| { + state.sequence(|state| { + super::hidden::skip(state).and_then(|state| { + state.match_string("c") + .or_else(|state| { + state.match_string("d") + }) + }) + }) + }) + }; + assert_eq!( + generate_expr(expr).to_string(), + quote! { + self::a(state).or_else(|state| { + state.sequence(|state| { + state.match_range('a'..'b').and_then(|state| { + super::hidden::skip(state) + }).and_then(|state| { + state.lookahead(false, |state| { + state.sequence(|state| { + state.optional(|state| { + state.match_insensitive( + "b" + ).and_then(|state| { + state.repeat(|state| { + #sequence + }) + }) + }) + }) + }) + }).and_then(|state| { + super::hidden::skip(state) + }).and_then(|state| { + state.lookahead(true, |state| { + state.optional(|state| { + state.sequence(|state| { + state.optional(|state| { + state.match_string("c") + .or_else(|state| { + state.match_string("d") + }).and_then(|state| { + #repeat + }) + }) + }) + }) + }) + }) + }) + }) + } + .to_string() + ); + } + + #[test] + fn expr_complex_atomic() { + let expr = OptimizedExpr::Choice( + Box::new(OptimizedExpr::Ident("a".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::Range("a".to_owned(), "b".to_owned())), + Box::new(OptimizedExpr::Seq( + Box::new(OptimizedExpr::NegPred(Box::new(OptimizedExpr::Rep( + Box::new(OptimizedExpr::Insens("b".to_owned())), + )))), + Box::new(OptimizedExpr::PosPred(Box::new(OptimizedExpr::Opt( + Box::new(OptimizedExpr::Rep(Box::new(OptimizedExpr::Choice( + Box::new(OptimizedExpr::Str("c".to_owned())), + Box::new(OptimizedExpr::Str("d".to_owned())), + )))), + )))), + )), + )), + ); + + assert_eq!( + generate_expr_atomic(expr).to_string(), + quote! { + self::a(state).or_else(|state| { + state.sequence(|state| { + state.match_range('a'..'b').and_then(|state| { + state.lookahead(false, |state| { + state.repeat(|state| { + state.match_insensitive("b") + }) + }) + }).and_then(|state| { + state.lookahead(true, |state| { + state.optional(|state| { + state.repeat(|state| { + state.match_string("c") + .or_else(|state| { + state.match_string("d") + }) + }) + }) + }) + }) + }) + }) + } + .to_string() + ); + } + + #[test] + fn generate_complete() { + let name = Ident::new("MyParser", Span::call_site()); + let generics = Generics::default(); + let rules = vec![OptimizedRule { + name: "a".to_owned(), + ty: RuleType::Silent, + expr: OptimizedExpr::Str("b".to_owned()), + }]; + let defaults = vec!["ANY"]; + let mut current_dir = std::env::current_dir().expect("Unable to get current directory"); + current_dir.push("test.pest"); + let test_path = current_dir.to_str().expect("path contains invalid unicode"); + assert_eq!( + generate(name, &generics, Some(PathBuf::from("test.pest")), rules, defaults, true).to_string(), + quote! { + #[allow(non_upper_case_globals)] + const _PEST_GRAMMAR_MyParser: &'static str = include_str!(#test_path); + + #[allow(dead_code, non_camel_case_types)] + #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub enum Rule { + a + } + + #[allow(clippy::all)] + impl ::pest::Parser<Rule> for MyParser { + fn parse<'i>( + rule: Rule, + input: &'i str + ) -> ::std::result::Result< + ::pest::iterators::Pairs<'i, Rule>, + ::pest::error::Error<Rule> + > { + mod rules { + pub mod hidden { + use super::super::Rule; + + #[inline] + #[allow(dead_code, non_snake_case, unused_variables)] + pub fn skip(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + Ok(state) + } + } + + pub mod visible { + use super::super::Rule; + + #[inline] + #[allow(non_snake_case, unused_variables)] + pub fn a(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.match_string("b") + } + + #[inline] + #[allow(dead_code, non_snake_case, unused_variables)] + pub fn ANY(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + state.skip(1) + } + } + + pub use self::visible::*; + } + + ::pest::state(input, |state| { + match rule { + Rule::a => rules::a(state) + } + }) + } + } + }.to_string() + ); + } +} diff --git a/vendor/pest_generator/src/lib.rs b/vendor/pest_generator/src/lib.rs new file mode 100644 index 000000000..27b4d8168 --- /dev/null +++ b/vendor/pest_generator/src/lib.rs @@ -0,0 +1,208 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#![doc(html_root_url = "https://docs.rs/pest_derive")] +#![recursion_limit = "256"] + +extern crate pest; +extern crate pest_meta; + +extern crate proc_macro; +extern crate proc_macro2; +#[macro_use] +extern crate quote; +extern crate syn; + +use std::env; +use std::fs::File; +use std::io::{self, Read}; +use std::path::Path; + +use proc_macro2::TokenStream; +use syn::{Attribute, DeriveInput, Generics, Ident, Lit, Meta}; + +#[macro_use] +mod macros; +mod generator; + +use pest_meta::parser::{self, Rule}; +use pest_meta::{optimizer, unwrap_or_report, validator}; + +pub fn derive_parser(input: TokenStream, include_grammar: bool) -> TokenStream { + let ast: DeriveInput = syn::parse2(input).unwrap(); + let (name, generics, content) = parse_derive(ast); + + let (data, path) = match content { + GrammarSource::File(ref path) => { + let root = env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| ".".into()); + let path = Path::new(&root).join("src/").join(&path); + let file_name = match path.file_name() { + Some(file_name) => file_name, + None => panic!("grammar attribute should point to a file"), + }; + + let data = match read_file(&path) { + Ok(data) => data, + Err(error) => panic!("error opening {:?}: {}", file_name, error), + }; + (data, Some(path.clone())) + } + GrammarSource::Inline(content) => (content, None), + }; + + let pairs = match parser::parse(Rule::grammar_rules, &data) { + Ok(pairs) => pairs, + Err(error) => panic!( + "error parsing \n{}", + error.renamed_rules(|rule| match *rule { + Rule::grammar_rule => "rule".to_owned(), + Rule::_push => "PUSH".to_owned(), + Rule::assignment_operator => "`=`".to_owned(), + Rule::silent_modifier => "`_`".to_owned(), + Rule::atomic_modifier => "`@`".to_owned(), + Rule::compound_atomic_modifier => "`$`".to_owned(), + Rule::non_atomic_modifier => "`!`".to_owned(), + Rule::opening_brace => "`{`".to_owned(), + Rule::closing_brace => "`}`".to_owned(), + Rule::opening_brack => "`[`".to_owned(), + Rule::closing_brack => "`]`".to_owned(), + Rule::opening_paren => "`(`".to_owned(), + Rule::positive_predicate_operator => "`&`".to_owned(), + Rule::negative_predicate_operator => "`!`".to_owned(), + Rule::sequence_operator => "`&`".to_owned(), + Rule::choice_operator => "`|`".to_owned(), + Rule::optional_operator => "`?`".to_owned(), + Rule::repeat_operator => "`*`".to_owned(), + Rule::repeat_once_operator => "`+`".to_owned(), + Rule::comma => "`,`".to_owned(), + Rule::closing_paren => "`)`".to_owned(), + Rule::quote => "`\"`".to_owned(), + Rule::insensitive_string => "`^`".to_owned(), + Rule::range_operator => "`..`".to_owned(), + Rule::single_quote => "`'`".to_owned(), + other_rule => format!("{:?}", other_rule), + }) + ), + }; + + let defaults = unwrap_or_report(validator::validate_pairs(pairs.clone())); + let ast = unwrap_or_report(parser::consume_rules(pairs)); + let optimized = optimizer::optimize(ast); + + generator::generate(name, &generics, path, optimized, defaults, include_grammar) +} + +fn read_file<P: AsRef<Path>>(path: P) -> io::Result<String> { + let mut file = File::open(path.as_ref())?; + let mut string = String::new(); + file.read_to_string(&mut string)?; + Ok(string) +} + +#[derive(Debug, PartialEq)] +enum GrammarSource { + File(String), + Inline(String), +} + +fn parse_derive(ast: DeriveInput) -> (Ident, Generics, GrammarSource) { + let name = ast.ident; + let generics = ast.generics; + + let grammar: Vec<&Attribute> = ast + .attrs + .iter() + .filter(|attr| match attr.parse_meta() { + Ok(Meta::NameValue(name_value)) => { + name_value.path.is_ident("grammar") || name_value.path.is_ident("grammar_inline") + } + _ => false, + }) + .collect(); + + let argument = match grammar.len() { + 0 => panic!("a grammar file needs to be provided with the #[grammar = \"PATH\"] or #[grammar_inline = \"GRAMMAR CONTENTS\"] attribute"), + 1 => get_attribute(grammar[0]), + _ => panic!("only 1 grammar file can be provided"), + }; + + (name, generics, argument) +} + +fn get_attribute(attr: &Attribute) -> GrammarSource { + match attr.parse_meta() { + Ok(Meta::NameValue(name_value)) => match name_value.lit { + Lit::Str(string) => { + if name_value.path.is_ident("grammar") { + GrammarSource::File(string.value()) + } else { + GrammarSource::Inline(string.value()) + } + } + _ => panic!("grammar attribute must be a string"), + }, + _ => panic!("grammar attribute must be of the form `grammar = \"...\"`"), + } +} + +#[cfg(test)] +mod tests { + use super::parse_derive; + use super::GrammarSource; + use syn; + + #[test] + fn derive_inline_file() { + let definition = " + #[other_attr] + #[grammar_inline = \"GRAMMAR\"] + pub struct MyParser<'a, T>; + "; + let ast = syn::parse_str(definition).unwrap(); + let (_, _, filename) = parse_derive(ast); + assert_eq!(filename, GrammarSource::Inline("GRAMMAR".to_string())); + } + + #[test] + fn derive_ok() { + let definition = " + #[other_attr] + #[grammar = \"myfile.pest\"] + pub struct MyParser<'a, T>; + "; + let ast = syn::parse_str(definition).unwrap(); + let (_, _, filename) = parse_derive(ast); + assert_eq!(filename, GrammarSource::File("myfile.pest".to_string())); + } + + #[test] + #[should_panic(expected = "only 1 grammar file can be provided")] + fn derive_multiple_grammars() { + let definition = " + #[other_attr] + #[grammar = \"myfile1.pest\"] + #[grammar = \"myfile2.pest\"] + pub struct MyParser<'a, T>; + "; + let ast = syn::parse_str(definition).unwrap(); + parse_derive(ast); + } + + #[test] + #[should_panic(expected = "grammar attribute must be a string")] + fn derive_wrong_arg() { + let definition = " + #[other_attr] + #[grammar = 1] + pub struct MyParser<'a, T>; + "; + let ast = syn::parse_str(definition).unwrap(); + parse_derive(ast); + } +} diff --git a/vendor/pest_generator/src/macros.rs b/vendor/pest_generator/src/macros.rs new file mode 100644 index 000000000..9d02725da --- /dev/null +++ b/vendor/pest_generator/src/macros.rs @@ -0,0 +1,44 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +macro_rules! insert_builtin { + ($builtin: expr, $name: ident, $pattern: expr) => { + $builtin.push((stringify!($name), generate_rule!($name, $pattern))); + }; +} + +macro_rules! insert_public_builtin { + ($builtin: expr, $name: ident, $pattern: expr) => { + $builtin.push((stringify!($name), generate_public_rule!($name, $pattern))); + }; +} + +macro_rules! generate_rule { + ($name: ident, $pattern: expr) => { + quote! { + #[inline] + #[allow(dead_code, non_snake_case, unused_variables)] + pub fn $name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + $pattern + } + } + } +} + +macro_rules! generate_public_rule { + ($name: ident, $pattern: expr) => { + quote! { + #[inline] + #[allow(dead_code, non_snake_case, unused_variables)] + pub fn $name(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { + $pattern + } + } + } +} diff --git a/vendor/pest_meta/.cargo-checksum.json b/vendor/pest_meta/.cargo-checksum.json new file mode 100644 index 000000000..f51cb5967 --- /dev/null +++ b/vendor/pest_meta/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"adf86f275ddc1ae02311ab5e1b51a165dc034edf466fc74dea6cbe63fe80d9b3","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","_README.md":"e9901b6c4d50403bfda7e08a92b5c395a8c51eba868c7bd07b03e00ccba702f3","src/ast.rs":"b2d0b054d66525b6c9ceed7a9b24cabcdd1074b525b230fc99a1a31019010f58","src/grammar.pest":"fac55bde3f3b59058293d220fec96ef033e61cb24fc032cad21d76aa6f963bc1","src/grammar.rs":"eb8f1f0c964467c081564de8830f3db4966499311868127342b9b651e8cee06f","src/lib.rs":"b248cf6bc5d4a8537f682c23f8d2c8910eb764ee5f1cc02b2c344b0b920943da","src/optimizer/concatenator.rs":"94c2a79d39ebeddbc413d30f2c20d0b50ae2c0e2e86bff90a029b70aa028e2fc","src/optimizer/factorizer.rs":"84df67d6e3f1b507b3e970cb8fba1ab9e2254c3ba778c4a0cf100452b36f1e08","src/optimizer/mod.rs":"69f25916112cbfa4b3d2225f8af463a03ebe706ae757d9c97be523c5601d7b3c","src/optimizer/restorer.rs":"182561b972752ec961fa45d0ca705a9852462010003e4e1ab646e5cd486bedd1","src/optimizer/rotater.rs":"e59f6c3e9197dc3cb4f21edf0c5ffb1a2638a81e4ce9b0373a2d2147a12a3bd5","src/optimizer/skipper.rs":"ab52c7a44a35aefcd1546da5e2084af642c472f07565dcb1be1bb3e2b5fc5a41","src/optimizer/unroller.rs":"99b4940906b0eb443a8b0bf6499130098d59a8141f2693ec50a653cb21c534d5","src/parser.rs":"04a93b2d36bcf199cbc5ab3e943a85cc1730529af83bb3f4a1a9f6b80e2eda4a","src/validator.rs":"5436c0cafc8fa91e45e4988e280220057c8f43ec7a796491abb8e9b22f80582d"},"package":"54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"}
\ No newline at end of file diff --git a/vendor/pest_meta/Cargo.toml b/vendor/pest_meta/Cargo.toml new file mode 100644 index 000000000..74f837745 --- /dev/null +++ b/vendor/pest_meta/Cargo.toml @@ -0,0 +1,42 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "pest_meta" +version = "2.1.3" +authors = ["Dragoș Tiselice <dragostiselice@gmail.com>"] +exclude = ["src/grammar.pest"] +include = ["Cargo.toml", "src/**/*", "src/grammar.rs", "_README.md", "LICENSE-*"] +description = "pest meta language parser and validator" +homepage = "https://pest-parser.github.io/" +documentation = "https://docs.rs/pest" +readme = "_README.md" +keywords = ["pest", "parser", "meta", "optimizer"] +categories = ["parsing"] +license = "MIT/Apache-2.0" +repository = "https://github.com/pest-parser/pest" +[dependencies.maplit] +version = "1.0" + +[dependencies.pest] +version = "2.1.0" +[build-dependencies.sha-1] +version = "0.8" +default-features = false +[badges.codecov] +repository = "pest-parser/pest" + +[badges.maintenance] +status = "actively-developed" + +[badges.travis-ci] +repository = "pest-parser/pest" diff --git a/vendor/pest_meta/LICENSE-APACHE b/vendor/pest_meta/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/vendor/pest_meta/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/pest_meta/LICENSE-MIT b/vendor/pest_meta/LICENSE-MIT new file mode 100644 index 000000000..31aa79387 --- /dev/null +++ b/vendor/pest_meta/LICENSE-MIT @@ -0,0 +1,23 @@ +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/pest_meta/_README.md b/vendor/pest_meta/_README.md new file mode 100644 index 000000000..8e55f29a2 --- /dev/null +++ b/vendor/pest_meta/_README.md @@ -0,0 +1,169 @@ +<p align="center"> + <img src="https://raw.github.com/pest-parser/pest/master/pest-logo.svg?sanitize=true" width="80%"/> +</p> + +# pest. The Elegant Parser + +[![Join the chat at https://gitter.im/dragostis/pest](https://badges.gitter.im/dragostis/pest.svg)](https://gitter.im/dragostis/pest?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +[![Book](https://img.shields.io/badge/book-WIP-4d76ae.svg)](https://pest-parser.github.io/book) +[![Docs](https://docs.rs/pest/badge.svg)](https://docs.rs/pest) + +[![Build Status](https://travis-ci.org/pest-parser/pest.svg?branch=master)](https://travis-ci.org/pest-parser/pest) +[![codecov](https://codecov.io/gh/pest-parser/pest/branch/master/graph/badge.svg)](https://codecov.io/gh/pest-parser/pest) +[![Fuzzit Status](https://app.fuzzit.dev/badge?org_id=pest-parser)](https://app.fuzzit.dev/orgs/pest-parser/dashboard) +[![Crates.io](https://img.shields.io/crates/d/pest.svg)](https://crates.io/crates/pest) +[![Crates.io](https://img.shields.io/crates/v/pest.svg)](https://crates.io/crates/pest) + +pest is a general purpose parser written in Rust with a focus on accessibility, +correctness, and performance. It uses parsing expression grammars +(or [PEG]) as input, which are similar in spirit to regular expressions, but +which offer the enhanced expressivity needed to parse complex languages. + +[PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar + +## Getting started + +The recommended way to start parsing with pest is to read the official [book]. + +Other helpful resources: + +* API reference on [docs.rs] +* play with grammars and share them on our [fiddle] +* leave feedback, ask questions, or greet us on [Gitter] + +[book]: https://pest-parser.github.io/book +[docs.rs]: https://docs.rs/pest +[fiddle]: https://pest-parser.github.io/#editor +[Gitter]: https://gitter.im/dragostis/pest + +## Example + +The following is an example of a grammar for a list of alpha-numeric identifiers +where the first identifier does not start with a digit: + +```rust +alpha = { 'a'..'z' | 'A'..'Z' } +digit = { '0'..'9' } + +ident = { (alpha | digit)+ } + +ident_list = _{ !digit ~ ident ~ (" " ~ ident)+ } + // ^ + // ident_list rule is silent which means it produces no tokens +``` + +Grammars are saved in separate .pest files which are never mixed with procedural +code. This results in an always up-to-date formalization of a language that is +easy to read and maintain. + +## Meaningful error reporting + +Based on the grammar definition, the parser also includes automatic error +reporting. For the example above, the input `"123"` will result in: + +``` +thread 'main' panicked at ' --> 1:1 + | +1 | 123 + | ^--- + | + = unexpected digit', src/main.rs:12 +``` +while `"ab *"` will result in: +``` +thread 'main' panicked at ' --> 1:1 + | +1 | ab * + | ^--- + | + = expected ident', src/main.rs:12 +``` + +## Pairs API + +The grammar can be used to derive a `Parser` implementation automatically. +Parsing returns an iterator of nested token pairs: + +```rust +extern crate pest; +#[macro_use] +extern crate pest_derive; + +use pest::Parser; + +#[derive(Parser)] +#[grammar = "ident.pest"] +struct IdentParser; + +fn main() { + let pairs = IdentParser::parse(Rule::ident_list, "a1 b2").unwrap_or_else(|e| panic!("{}", e)); + + // Because ident_list is silent, the iterator will contain idents + for pair in pairs { + // A pair is a combination of the rule which matched and a span of input + println!("Rule: {:?}", pair.as_rule()); + println!("Span: {:?}", pair.as_span()); + println!("Text: {}", pair.as_str()); + + // A pair can be converted to an iterator of the tokens which make it up: + for inner_pair in pair.into_inner() { + match inner_pair.as_rule() { + Rule::alpha => println!("Letter: {}", inner_pair.as_str()), + Rule::digit => println!("Digit: {}", inner_pair.as_str()), + _ => unreachable!() + }; + } + } +} +``` + +This produces the following output: +``` +Rule: ident +Span: Span { start: 0, end: 2 } +Text: a1 +Letter: a +Digit: 1 +Rule: ident +Span: Span { start: 3, end: 5 } +Text: b2 +Letter: b +Digit: 2 +``` + +## Other features + +* Precedence climbing +* Input handling +* Custom errors +* Runs on stable Rust + +## Projects using pest + +* [pest_meta](https://github.com/pest-parser/pest/blob/master/meta/src/grammar.pest) (bootstrapped) +* [AshPaper](https://github.com/shnewto/ashpaper) +* [brain](https://github.com/brain-lang/brain) +* [Chelone](https://github.com/Aaronepower/chelone) +* [comrak](https://github.com/kivikakk/comrak) +* [elastic-rs](https://github.com/cch123/elastic-rs) +* [graphql-parser](https://github.com/Keats/graphql-parser) +* [handlebars-rust](https://github.com/sunng87/handlebars-rust) +* [hexdino](https://github.com/Luz/hexdino) +* [Huia](https://gitlab.com/jimsy/huia/) +* [jql](https://github.com/yamafaktory/jql) +* [json5-rs](https://github.com/callum-oakley/json5-rs) +* [mt940](https://github.com/svenstaro/mt940-rs) +* [py_literal](https://github.com/jturner314/py_literal) +* [rouler](https://github.com/jarcane/rouler) +* [RuSh](https://github.com/lwandrebeck/RuSh) +* [rs_pbrt](https://github.com/wahn/rs_pbrt) +* [stache](https://github.com/dgraham/stache) +* [tera](https://github.com/Keats/tera) +* [ui_gen](https://github.com/emoon/ui_gen) +* [ukhasnet-parser](https://github.com/adamgreig/ukhasnet-parser) +* [ZoKrates](https://github.com/ZoKrates/ZoKrates) + +## Special thanks + +A special round of applause goes to prof. Marius Minea for his guidance and all +pest contributors, some of which being none other than my friends. diff --git a/vendor/pest_meta/src/ast.rs b/vendor/pest_meta/src/ast.rs new file mode 100644 index 000000000..b80c59630 --- /dev/null +++ b/vendor/pest_meta/src/ast.rs @@ -0,0 +1,315 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct Rule { + pub name: String, + pub ty: RuleType, + pub expr: Expr, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum RuleType { + Normal, + Silent, + Atomic, + CompoundAtomic, + NonAtomic, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum Expr { + /// Matches an exact string, e.g. `"a"` + Str(String), + /// Matches an exact string, case insensitively (ASCII only), e.g. `^"a"` + Insens(String), + /// Matches one character in the range, e.g. `'a'..'z'` + Range(String, String), + /// Matches the rule with the given name, e.g. `a` + Ident(String), + /// Matches a custom part of the stack, e.g. `PEEK[..]` + PeekSlice(i32, Option<i32>), + /// Positive lookahead; matches expression without making progress, e.g. `&e` + PosPred(Box<Expr>), + /// Negative lookahead; matches if expression doesn't match, without making progress, e.g. `!e` + NegPred(Box<Expr>), + /// Matches a sequence of two expressions, e.g. `e1 ~ e2` + Seq(Box<Expr>, Box<Expr>), + /// Matches either of two expressions, e.g. `e1 | e2` + Choice(Box<Expr>, Box<Expr>), + /// Optionally matches an expression, e.g. `e?` + Opt(Box<Expr>), + /// Matches an expression zero or more times, e.g. `e*` + Rep(Box<Expr>), + /// Matches an expression one or more times, e.g. `e+` + RepOnce(Box<Expr>), + /// Matches an expression an exact number of times, e.g. `e{n}` + RepExact(Box<Expr>, u32), + /// Matches an expression at least a number of times, e.g. `e{n,}` + RepMin(Box<Expr>, u32), + /// Matches an expression at most a number of times, e.g. `e{,n}` + RepMax(Box<Expr>, u32), + /// Matches an expression a number of times within a range, e.g. `e{m, n}` + RepMinMax(Box<Expr>, u32, u32), + /// Continues to match expressions until one of the strings in the `Vec` is found + Skip(Vec<String>), + /// Matches an expression and pushes it to the stack, e.g. `push(e)` + Push(Box<Expr>), +} + +impl Expr { + pub fn iter_top_down(&self) -> ExprTopDownIterator { + ExprTopDownIterator::new(self) + } + + pub fn map_top_down<F>(self, mut f: F) -> Expr + where + F: FnMut(Expr) -> Expr, + { + fn map_internal<F>(expr: Expr, f: &mut F) -> Expr + where + F: FnMut(Expr) -> Expr, + { + let expr = f(expr); + + match expr { + // TODO: Use box syntax when it gets stabilized. + Expr::PosPred(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::PosPred(mapped) + } + Expr::NegPred(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::NegPred(mapped) + } + Expr::Seq(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + Expr::Seq(mapped_lhs, mapped_rhs) + } + Expr::Choice(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + Expr::Choice(mapped_lhs, mapped_rhs) + } + Expr::Rep(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::Rep(mapped) + } + Expr::RepOnce(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepOnce(mapped) + } + Expr::RepExact(expr, max) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepExact(mapped, max) + } + Expr::RepMin(expr, num) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepMin(mapped, num) + } + Expr::RepMax(expr, num) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepMax(mapped, num) + } + Expr::RepMinMax(expr, min, max) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepMinMax(mapped, min, max) + } + Expr::Opt(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::Opt(mapped) + } + Expr::Push(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::Push(mapped) + } + expr => expr, + } + } + + map_internal(self, &mut f) + } + + pub fn map_bottom_up<F>(self, mut f: F) -> Expr + where + F: FnMut(Expr) -> Expr, + { + fn map_internal<F>(expr: Expr, f: &mut F) -> Expr + where + F: FnMut(Expr) -> Expr, + { + let mapped = match expr { + Expr::PosPred(expr) => { + // TODO: Use box syntax when it gets stabilized. + let mapped = Box::new(map_internal(*expr, f)); + Expr::PosPred(mapped) + } + Expr::NegPred(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::NegPred(mapped) + } + Expr::Seq(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + Expr::Seq(mapped_lhs, mapped_rhs) + } + Expr::Choice(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + Expr::Choice(mapped_lhs, mapped_rhs) + } + Expr::Rep(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::Rep(mapped) + } + Expr::RepOnce(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepOnce(mapped) + } + Expr::RepExact(expr, num) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepExact(mapped, num) + } + Expr::RepMin(expr, max) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepMin(mapped, max) + } + Expr::RepMax(expr, max) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepMax(mapped, max) + } + Expr::RepMinMax(expr, min, max) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::RepMinMax(mapped, min, max) + } + Expr::Opt(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::Opt(mapped) + } + Expr::Push(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + Expr::Push(mapped) + } + expr => expr, + }; + + f(mapped) + } + + map_internal(self, &mut f) + } +} + +pub struct ExprTopDownIterator { + current: Option<Expr>, + next: Option<Expr>, + right_branches: Vec<Expr>, +} + +impl ExprTopDownIterator { + pub fn new(expr: &Expr) -> Self { + let mut iter = ExprTopDownIterator { + current: None, + next: None, + right_branches: vec![], + }; + iter.iterate_expr(expr.clone()); + iter + } + + fn iterate_expr(&mut self, expr: Expr) { + self.current = Some(expr.clone()); + match expr { + Expr::Seq(lhs, rhs) => { + self.right_branches.push(*rhs); + self.next = Some(*lhs); + } + Expr::Choice(lhs, rhs) => { + self.right_branches.push(*rhs); + self.next = Some(*lhs); + } + Expr::PosPred(expr) + | Expr::NegPred(expr) + | Expr::Rep(expr) + | Expr::RepOnce(expr) + | Expr::RepExact(expr, _) + | Expr::RepMin(expr, _) + | Expr::RepMax(expr, _) + | Expr::RepMinMax(expr, ..) + | Expr::Opt(expr) + | Expr::Push(expr) => { + self.next = Some(*expr); + } + _ => { + self.next = None; + } + } + } +} + +impl Iterator for ExprTopDownIterator { + type Item = Expr; + + fn next(&mut self) -> Option<Self::Item> { + let result = self.current.take(); + + if let Some(expr) = self.next.take() { + self.iterate_expr(expr); + } else if let Some(expr) = self.right_branches.pop() { + self.iterate_expr(expr); + } + + result + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn top_down_iterator() { + let expr = Expr::Choice( + Box::new(Expr::Str(String::from("a"))), + Box::new(Expr::Str(String::from("b"))), + ); + let mut top_down = expr.clone().iter_top_down(); + assert_eq!(top_down.next(), Some(expr)); + assert_eq!(top_down.next(), Some(Expr::Str(String::from("a")))); + assert_eq!(top_down.next(), Some(Expr::Str(String::from("b")))); + assert_eq!(top_down.next(), None); + } + + #[test] + fn identity() { + let expr = Expr::Choice( + Box::new(Expr::Seq( + Box::new(Expr::Ident("a".to_owned())), + Box::new(Expr::Str("b".to_owned())), + )), + Box::new(Expr::PosPred(Box::new(Expr::NegPred(Box::new(Expr::Rep( + Box::new(Expr::RepOnce(Box::new(Expr::Opt(Box::new(Expr::Choice( + Box::new(Expr::Insens("c".to_owned())), + Box::new(Expr::Push(Box::new(Expr::Range( + "'d'".to_owned(), + "'e'".to_owned(), + )))), + )))))), + )))))), + ); + + assert_eq!( + expr.clone() + .map_bottom_up(|expr| expr) + .map_top_down(|expr| expr), + expr + ); + } +} diff --git a/vendor/pest_meta/src/grammar.pest b/vendor/pest_meta/src/grammar.pest new file mode 100644 index 000000000..0d03ba899 --- /dev/null +++ b/vendor/pest_meta/src/grammar.pest @@ -0,0 +1,98 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +grammar_rules = _{ SOI ~ grammar_rule+ ~ EOI } + +grammar_rule = { + identifier ~ assignment_operator ~ modifier? ~ + opening_brace ~ expression ~ closing_brace +} + +assignment_operator = { "=" } +opening_brace = { "{" } +closing_brace = { "}" } +opening_paren = { "(" } +closing_paren = { ")" } +opening_brack = { "[" } +closing_brack = { "]" } + +modifier = _{ + silent_modifier | + atomic_modifier | + compound_atomic_modifier | + non_atomic_modifier +} + +silent_modifier = { "_" } +atomic_modifier = { "@" } +compound_atomic_modifier = { "$" } +non_atomic_modifier = { "!" } + +expression = { term ~ (infix_operator ~ term)* } +term = { prefix_operator* ~ node ~ postfix_operator* } +node = _{ opening_paren ~ expression ~ closing_paren | terminal } +terminal = _{ _push | peek_slice | identifier | string | insensitive_string | range } + +prefix_operator = _{ positive_predicate_operator | negative_predicate_operator } +infix_operator = _{ sequence_operator | choice_operator } +postfix_operator = _{ + optional_operator | + repeat_operator | + repeat_once_operator | + repeat_exact | + repeat_min | + repeat_max | + repeat_min_max +} + +positive_predicate_operator = { "&" } +negative_predicate_operator = { "!" } +sequence_operator = { "~" } +choice_operator = { "|" } +optional_operator = { "?" } +repeat_operator = { "*" } +repeat_once_operator = { "+" } + +repeat_exact = { opening_brace ~ number ~ closing_brace } +repeat_min = { opening_brace ~ number ~ comma ~ closing_brace } +repeat_max = { opening_brace ~ comma ~ number ~ closing_brace } +repeat_min_max = { opening_brace ~ number ~ comma ~ number ~ closing_brace } + +number = @{ '0'..'9'+ } +integer = @{ number | "-" ~ "0"* ~ '1'..'9' ~ number? } + +comma = { "," } + +_push = { "PUSH" ~ opening_paren ~ expression ~ closing_paren } +peek_slice = { "PEEK" ~ opening_brack ~ integer? ~ range_operator ~ integer? ~ closing_brack } + +identifier = @{ !"PUSH" ~ ("_" | alpha) ~ ("_" | alpha_num)* } +alpha = _{ 'a'..'z' | 'A'..'Z' } +alpha_num = _{ alpha | '0'..'9' } + +string = ${ quote ~ inner_str ~ quote } +insensitive_string = { "^" ~ string } +range = { character ~ range_operator ~ character } +character = ${ single_quote ~ inner_chr ~ single_quote } + +inner_str = @{ (!("\"" | "\\") ~ ANY)* ~ (escape ~ inner_str)? } +inner_chr = @{ escape | ANY } +escape = @{ "\\" ~ ("\"" | "\\" | "r" | "n" | "t" | "0" | "'" | code | unicode) } +code = @{ "x" ~ hex_digit{2} } +unicode = @{ "u" ~ opening_brace ~ hex_digit{2, 6} ~ closing_brace } +hex_digit = @{ '0'..'9' | 'a'..'f' | 'A'..'F' } + +quote = { "\"" } +single_quote = { "'" } +range_operator = { ".." } + +newline = _{ "\n" | "\r\n" } +WHITESPACE = _{ " " | "\t" | newline } +block_comment = _{ "/*" ~ (block_comment | !"*/" ~ ANY)* ~ "*/" } +COMMENT = _{ block_comment | ("//" ~ (!newline ~ ANY)*) } diff --git a/vendor/pest_meta/src/grammar.rs b/vendor/pest_meta/src/grammar.rs new file mode 100644 index 000000000..bf94a1e3a --- /dev/null +++ b/vendor/pest_meta/src/grammar.rs @@ -0,0 +1,2 @@ +pub struct PestParser; +# [ allow ( dead_code , non_camel_case_types ) ] # [ derive ( Clone , Copy , Debug , Eq , Hash , Ord , PartialEq , PartialOrd ) ] pub enum Rule { EOI , grammar_rules , grammar_rule , assignment_operator , opening_brace , closing_brace , opening_paren , closing_paren , opening_brack , closing_brack , modifier , silent_modifier , atomic_modifier , compound_atomic_modifier , non_atomic_modifier , expression , term , node , terminal , prefix_operator , infix_operator , postfix_operator , positive_predicate_operator , negative_predicate_operator , sequence_operator , choice_operator , optional_operator , repeat_operator , repeat_once_operator , repeat_exact , repeat_min , repeat_max , repeat_min_max , number , integer , comma , _push , peek_slice , identifier , alpha , alpha_num , string , insensitive_string , range , character , inner_str , inner_chr , escape , code , unicode , hex_digit , quote , single_quote , range_operator , newline , WHITESPACE , block_comment , COMMENT } # [ allow ( clippy :: all ) ] impl :: pest :: Parser < Rule > for PestParser { fn parse < 'i > ( rule : Rule , input : & 'i str ) -> :: std :: result :: Result < :: pest :: iterators :: Pairs < 'i , Rule > , :: pest :: error :: Error < Rule > > { mod rules { pub mod hidden { use super :: super :: Rule ; # [ inline ] # [ allow ( dead_code , non_snake_case , unused_variables ) ] pub fn skip ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { if state . atomicity ( ) == :: pest :: Atomicity :: NonAtomic { state . sequence ( | state | { state . repeat ( | state | super :: visible :: WHITESPACE ( state ) ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { super :: visible :: COMMENT ( state ) . and_then ( | state | { state . repeat ( | state | super :: visible :: WHITESPACE ( state ) ) } ) } ) } ) } ) } ) } else { Ok ( state ) } } } pub mod visible { use super :: super :: Rule ; # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn grammar_rules ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . sequence ( | state | { self :: SOI ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . sequence ( | state | { self :: grammar_rule ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . sequence ( | state | { state . optional ( | state | { self :: grammar_rule ( state ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { super :: hidden :: skip ( state ) . and_then ( | state | { self :: grammar_rule ( state ) } ) } ) } ) } ) } ) } ) } ) } ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: EOI ( state ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn grammar_rule ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: grammar_rule , | state | { state . sequence ( | state | { self :: identifier ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: assignment_operator ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . optional ( | state | { self :: modifier ( state ) } ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: opening_brace ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: expression ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_brace ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn assignment_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: assignment_operator , | state | { state . match_string ( "=" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn opening_brace ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: opening_brace , | state | { state . match_string ( "{" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn closing_brace ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: closing_brace , | state | { state . match_string ( "}" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn opening_paren ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: opening_paren , | state | { state . match_string ( "(" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn closing_paren ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: closing_paren , | state | { state . match_string ( ")" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn opening_brack ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: opening_brack , | state | { state . match_string ( "[" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn closing_brack ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: closing_brack , | state | { state . match_string ( "]" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn modifier ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { self :: silent_modifier ( state ) . or_else ( | state | { self :: atomic_modifier ( state ) } ) . or_else ( | state | { self :: compound_atomic_modifier ( state ) } ) . or_else ( | state | { self :: non_atomic_modifier ( state ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn silent_modifier ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: silent_modifier , | state | { state . match_string ( "_" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn atomic_modifier ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: atomic_modifier , | state | { state . match_string ( "@" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn compound_atomic_modifier ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: compound_atomic_modifier , | state | { state . match_string ( "$" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn non_atomic_modifier ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: non_atomic_modifier , | state | { state . match_string ( "!" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn expression ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: expression , | state | { state . sequence ( | state | { self :: term ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . sequence ( | state | { state . optional ( | state | { state . sequence ( | state | { self :: infix_operator ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: term ( state ) } ) } ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { super :: hidden :: skip ( state ) . and_then ( | state | { state . sequence ( | state | { self :: infix_operator ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: term ( state ) } ) } ) } ) } ) } ) } ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn term ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: term , | state | { state . sequence ( | state | { state . sequence ( | state | { state . optional ( | state | { self :: prefix_operator ( state ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { super :: hidden :: skip ( state ) . and_then ( | state | { self :: prefix_operator ( state ) } ) } ) } ) } ) } ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: node ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . sequence ( | state | { state . optional ( | state | { self :: postfix_operator ( state ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { super :: hidden :: skip ( state ) . and_then ( | state | { self :: postfix_operator ( state ) } ) } ) } ) } ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn node ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . sequence ( | state | { self :: opening_paren ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: expression ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_paren ( state ) } ) } ) . or_else ( | state | { self :: terminal ( state ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn terminal ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { self :: _push ( state ) . or_else ( | state | { self :: peek_slice ( state ) } ) . or_else ( | state | { self :: identifier ( state ) } ) . or_else ( | state | { self :: string ( state ) } ) . or_else ( | state | { self :: insensitive_string ( state ) } ) . or_else ( | state | { self :: range ( state ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn prefix_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { self :: positive_predicate_operator ( state ) . or_else ( | state | { self :: negative_predicate_operator ( state ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn infix_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { self :: sequence_operator ( state ) . or_else ( | state | { self :: choice_operator ( state ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn postfix_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { self :: optional_operator ( state ) . or_else ( | state | { self :: repeat_operator ( state ) } ) . or_else ( | state | { self :: repeat_once_operator ( state ) } ) . or_else ( | state | { self :: repeat_exact ( state ) } ) . or_else ( | state | { self :: repeat_min ( state ) } ) . or_else ( | state | { self :: repeat_max ( state ) } ) . or_else ( | state | { self :: repeat_min_max ( state ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn positive_predicate_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: positive_predicate_operator , | state | { state . match_string ( "&" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn negative_predicate_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: negative_predicate_operator , | state | { state . match_string ( "!" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn sequence_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: sequence_operator , | state | { state . match_string ( "~" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn choice_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: choice_operator , | state | { state . match_string ( "|" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn optional_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: optional_operator , | state | { state . match_string ( "?" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn repeat_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: repeat_operator , | state | { state . match_string ( "*" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn repeat_once_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: repeat_once_operator , | state | { state . match_string ( "+" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn repeat_exact ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: repeat_exact , | state | { state . sequence ( | state | { self :: opening_brace ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: number ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_brace ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn repeat_min ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: repeat_min , | state | { state . sequence ( | state | { self :: opening_brace ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: number ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: comma ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_brace ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn repeat_max ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: repeat_max , | state | { state . sequence ( | state | { self :: opening_brace ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: comma ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: number ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_brace ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn repeat_min_max ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: repeat_min_max , | state | { state . sequence ( | state | { self :: opening_brace ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: number ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: comma ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: number ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_brace ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn number ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: number , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . sequence ( | state | { state . match_range ( '0' .. '9' ) . and_then ( | state | { state . repeat ( | state | { state . match_range ( '0' .. '9' ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn integer ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: integer , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { self :: number ( state ) . or_else ( | state | { state . sequence ( | state | { state . match_string ( "-" ) . and_then ( | state | { state . repeat ( | state | { state . match_string ( "0" ) } ) } ) . and_then ( | state | { state . match_range ( '1' .. '9' ) } ) . and_then ( | state | { state . optional ( | state | { self :: number ( state ) } ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn comma ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: comma , | state | { state . match_string ( "," ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn _push ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: _push , | state | { state . sequence ( | state | { state . match_string ( "PUSH" ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: opening_paren ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: expression ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_paren ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn peek_slice ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: peek_slice , | state | { state . sequence ( | state | { state . match_string ( "PEEK" ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: opening_brack ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . optional ( | state | { self :: integer ( state ) } ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: range_operator ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . optional ( | state | { self :: integer ( state ) } ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: closing_brack ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn identifier ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: identifier , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . sequence ( | state | { state . lookahead ( false , | state | { state . match_string ( "PUSH" ) } ) . and_then ( | state | { state . match_string ( "_" ) . or_else ( | state | { self :: alpha ( state ) } ) } ) . and_then ( | state | { state . repeat ( | state | { state . match_string ( "_" ) . or_else ( | state | { self :: alpha_num ( state ) } ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn alpha ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . match_range ( 'a' .. 'z' ) . or_else ( | state | { state . match_range ( 'A' .. 'Z' ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn alpha_num ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { self :: alpha ( state ) . or_else ( | state | { state . match_range ( '0' .. '9' ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn string ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . atomic ( :: pest :: Atomicity :: CompoundAtomic , | state | { state . rule ( Rule :: string , | state | { state . sequence ( | state | { self :: quote ( state ) . and_then ( | state | { self :: inner_str ( state ) } ) . and_then ( | state | { self :: quote ( state ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn insensitive_string ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: insensitive_string , | state | { state . sequence ( | state | { state . match_string ( "^" ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: string ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn range ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: range , | state | { state . sequence ( | state | { self :: character ( state ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: range_operator ( state ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: character ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn character ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . atomic ( :: pest :: Atomicity :: CompoundAtomic , | state | { state . rule ( Rule :: character , | state | { state . sequence ( | state | { self :: single_quote ( state ) . and_then ( | state | { self :: inner_chr ( state ) } ) . and_then ( | state | { self :: single_quote ( state ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn inner_str ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: inner_str , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . sequence ( | state | { let strings = [ "\"" , "\\" ] ; state . skip_until ( & strings ) . and_then ( | state | { state . optional ( | state | { state . sequence ( | state | { self :: escape ( state ) . and_then ( | state | { self :: inner_str ( state ) } ) } ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn inner_chr ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: inner_chr , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { self :: escape ( state ) . or_else ( | state | { self :: ANY ( state ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn escape ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: escape , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . sequence ( | state | { state . match_string ( "\\" ) . and_then ( | state | { state . match_string ( "\"" ) . or_else ( | state | { state . match_string ( "\\" ) } ) . or_else ( | state | { state . match_string ( "r" ) } ) . or_else ( | state | { state . match_string ( "n" ) } ) . or_else ( | state | { state . match_string ( "t" ) } ) . or_else ( | state | { state . match_string ( "0" ) } ) . or_else ( | state | { state . match_string ( "'" ) } ) . or_else ( | state | { self :: code ( state ) } ) . or_else ( | state | { self :: unicode ( state ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn code ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: code , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . sequence ( | state | { state . match_string ( "x" ) . and_then ( | state | { self :: hex_digit ( state ) } ) . and_then ( | state | { self :: hex_digit ( state ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn unicode ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: unicode , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . sequence ( | state | { state . match_string ( "u" ) . and_then ( | state | { self :: opening_brace ( state ) } ) . and_then ( | state | { state . sequence ( | state | { self :: hex_digit ( state ) . and_then ( | state | { self :: hex_digit ( state ) } ) . and_then ( | state | { state . optional ( | state | { self :: hex_digit ( state ) } ) } ) . and_then ( | state | { state . optional ( | state | { self :: hex_digit ( state ) } ) } ) . and_then ( | state | { state . optional ( | state | { self :: hex_digit ( state ) } ) } ) . and_then ( | state | { state . optional ( | state | { self :: hex_digit ( state ) } ) } ) } ) } ) . and_then ( | state | { self :: closing_brace ( state ) } ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn hex_digit ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: hex_digit , | state | { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . match_range ( '0' .. '9' ) . or_else ( | state | { state . match_range ( 'a' .. 'f' ) } ) . or_else ( | state | { state . match_range ( 'A' .. 'F' ) } ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn quote ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: quote , | state | { state . match_string ( "\"" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn single_quote ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: single_quote , | state | { state . match_string ( "'" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn range_operator ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: range_operator , | state | { state . match_string ( ".." ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn newline ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . match_string ( "\n" ) . or_else ( | state | { state . match_string ( "\r\n" ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn WHITESPACE ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { state . match_string ( " " ) . or_else ( | state | { state . match_string ( "\t" ) } ) . or_else ( | state | { self :: newline ( state ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn block_comment ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . sequence ( | state | { state . match_string ( "/*" ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . sequence ( | state | { state . optional ( | state | { self :: block_comment ( state ) . or_else ( | state | { state . sequence ( | state | { state . lookahead ( false , | state | { state . match_string ( "*/" ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: ANY ( state ) } ) } ) } ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { super :: hidden :: skip ( state ) . and_then ( | state | { self :: block_comment ( state ) . or_else ( | state | { state . sequence ( | state | { state . lookahead ( false , | state | { state . match_string ( "*/" ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { self :: ANY ( state ) } ) } ) } ) } ) } ) } ) } ) } ) } ) } ) . and_then ( | state | { super :: hidden :: skip ( state ) } ) . and_then ( | state | { state . match_string ( "*/" ) } ) } ) } # [ inline ] # [ allow ( non_snake_case , unused_variables ) ] pub fn COMMENT ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . atomic ( :: pest :: Atomicity :: Atomic , | state | { self :: block_comment ( state ) . or_else ( | state | { state . sequence ( | state | { state . match_string ( "//" ) . and_then ( | state | { state . repeat ( | state | { state . sequence ( | state | { state . lookahead ( false , | state | { self :: newline ( state ) } ) . and_then ( | state | { self :: ANY ( state ) } ) } ) } ) } ) } ) } ) } ) } # [ inline ] # [ allow ( dead_code , non_snake_case , unused_variables ) ] pub fn SOI ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . start_of_input ( ) } # [ inline ] # [ allow ( dead_code , non_snake_case , unused_variables ) ] pub fn ANY ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . skip ( 1 ) } # [ inline ] # [ allow ( dead_code , non_snake_case , unused_variables ) ] pub fn EOI ( state : Box < :: pest :: ParserState < Rule >> ) -> :: pest :: ParseResult < Box < :: pest :: ParserState < Rule >> > { state . rule ( Rule :: EOI , | state | state . end_of_input ( ) ) } } pub use self :: visible :: * ; } :: pest :: state ( input , | state | { match rule { Rule :: grammar_rules => rules :: grammar_rules ( state ) , Rule :: grammar_rule => rules :: grammar_rule ( state ) , Rule :: assignment_operator => rules :: assignment_operator ( state ) , Rule :: opening_brace => rules :: opening_brace ( state ) , Rule :: closing_brace => rules :: closing_brace ( state ) , Rule :: opening_paren => rules :: opening_paren ( state ) , Rule :: closing_paren => rules :: closing_paren ( state ) , Rule :: opening_brack => rules :: opening_brack ( state ) , Rule :: closing_brack => rules :: closing_brack ( state ) , Rule :: modifier => rules :: modifier ( state ) , Rule :: silent_modifier => rules :: silent_modifier ( state ) , Rule :: atomic_modifier => rules :: atomic_modifier ( state ) , Rule :: compound_atomic_modifier => rules :: compound_atomic_modifier ( state ) , Rule :: non_atomic_modifier => rules :: non_atomic_modifier ( state ) , Rule :: expression => rules :: expression ( state ) , Rule :: term => rules :: term ( state ) , Rule :: node => rules :: node ( state ) , Rule :: terminal => rules :: terminal ( state ) , Rule :: prefix_operator => rules :: prefix_operator ( state ) , Rule :: infix_operator => rules :: infix_operator ( state ) , Rule :: postfix_operator => rules :: postfix_operator ( state ) , Rule :: positive_predicate_operator => rules :: positive_predicate_operator ( state ) , Rule :: negative_predicate_operator => rules :: negative_predicate_operator ( state ) , Rule :: sequence_operator => rules :: sequence_operator ( state ) , Rule :: choice_operator => rules :: choice_operator ( state ) , Rule :: optional_operator => rules :: optional_operator ( state ) , Rule :: repeat_operator => rules :: repeat_operator ( state ) , Rule :: repeat_once_operator => rules :: repeat_once_operator ( state ) , Rule :: repeat_exact => rules :: repeat_exact ( state ) , Rule :: repeat_min => rules :: repeat_min ( state ) , Rule :: repeat_max => rules :: repeat_max ( state ) , Rule :: repeat_min_max => rules :: repeat_min_max ( state ) , Rule :: number => rules :: number ( state ) , Rule :: integer => rules :: integer ( state ) , Rule :: comma => rules :: comma ( state ) , Rule :: _push => rules :: _push ( state ) , Rule :: peek_slice => rules :: peek_slice ( state ) , Rule :: identifier => rules :: identifier ( state ) , Rule :: alpha => rules :: alpha ( state ) , Rule :: alpha_num => rules :: alpha_num ( state ) , Rule :: string => rules :: string ( state ) , Rule :: insensitive_string => rules :: insensitive_string ( state ) , Rule :: range => rules :: range ( state ) , Rule :: character => rules :: character ( state ) , Rule :: inner_str => rules :: inner_str ( state ) , Rule :: inner_chr => rules :: inner_chr ( state ) , Rule :: escape => rules :: escape ( state ) , Rule :: code => rules :: code ( state ) , Rule :: unicode => rules :: unicode ( state ) , Rule :: hex_digit => rules :: hex_digit ( state ) , Rule :: quote => rules :: quote ( state ) , Rule :: single_quote => rules :: single_quote ( state ) , Rule :: range_operator => rules :: range_operator ( state ) , Rule :: newline => rules :: newline ( state ) , Rule :: WHITESPACE => rules :: WHITESPACE ( state ) , Rule :: block_comment => rules :: block_comment ( state ) , Rule :: COMMENT => rules :: COMMENT ( state ) , Rule :: EOI => rules :: EOI ( state ) } } ) } } diff --git a/vendor/pest_meta/src/lib.rs b/vendor/pest_meta/src/lib.rs new file mode 100644 index 000000000..1f9c5bcb6 --- /dev/null +++ b/vendor/pest_meta/src/lib.rs @@ -0,0 +1,134 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +#![allow(clippy::range_plus_one)] + +extern crate maplit; +#[cfg(test)] +#[macro_use] +extern crate pest; +#[cfg(not(test))] +extern crate pest; + +use std::fmt::Display; + +pub mod ast; +pub mod optimizer; +pub mod parser; +pub mod validator; + +pub fn unwrap_or_report<T, E>(result: Result<T, E>) -> T +where + E: IntoIterator, + E::Item: Display, +{ + result.unwrap_or_else(|e| { + panic!( + "grammar error\n\n".to_owned() + + &e.into_iter() + .map(|error| format!("{}", error)) + .collect::<Vec<_>>() + .join("\n\n") + ) + }) +} + +#[doc(hidden)] +pub static UNICODE_PROPERTY_NAMES: &[&str] = &[ + /* BINARY */ "ALPHABETIC", + "BIDI_CONTROL", + "CASE_IGNORABLE", + "CASED", + "CHANGES_WHEN_CASEFOLDED", + "CHANGES_WHEN_CASEMAPPED", + "CHANGES_WHEN_LOWERCASED", + "CHANGES_WHEN_TITLECASED", + "CHANGES_WHEN_UPPERCASED", + "DASH", + "DEFAULT_IGNORABLE_CODE_POINT", + "DEPRECATED", + "DIACRITIC", + "EXTENDER", + "GRAPHEME_BASE", + "GRAPHEME_EXTEND", + "GRAPHEME_LINK", + "HEX_DIGIT", + "HYPHEN", + "IDS_BINARY_OPERATOR", + "IDS_TRINARY_OPERATOR", + "ID_CONTINUE", + "ID_START", + "IDEOGRAPHIC", + "JOIN_CONTROL", + "LOGICAL_ORDER_EXCEPTION", + "LOWERCASE", + "MATH", + "NONCHARACTER_CODE_POINT", + "OTHER_ALPHABETIC", + "OTHER_DEFAULT_IGNORABLE_CODE_POINT", + "OTHER_GRAPHEME_EXTEND", + "OTHER_ID_CONTINUE", + "OTHER_ID_START", + "OTHER_LOWERCASE", + "OTHER_MATH", + "OTHER_UPPERCASE", + "PATTERN_SYNTAX", + "PATTERN_WHITE_SPACE", + "PREPENDED_CONCATENATION_MARK", + "QUOTATION_MARK", + "RADICAL", + "REGIONAL_INDICATOR", + "SENTENCE_TERMINAL", + "SOFT_DOTTED", + "TERMINAL_PUNCTUATION", + "UNIFIED_IDEOGRAPH", + "UPPERCASE", + "VARIATION_SELECTOR", + "WHITE_SPACE", + "XID_CONTINUE", + "XID_START", + /* CATEGORY */ "CASED_LETTER", + "CLOSE_PUNCTUATION", + "CONNECTOR_PUNCTUATION", + "CONTROL", + "CURRENCY_SYMBOL", + "DASH_PUNCTUATION", + "DECIMAL_NUMBER", + "ENCLOSING_MARK", + "FINAL_PUNCTUATION", + "FORMAT", + "INITIAL_PUNCTUATION", + "LETTER", + "LETTER_NUMBER", + "LINE_SEPARATOR", + "LOWERCASE_LETTER", + "MARK", + "MATH_SYMBOL", + "MODIFIER_LETTER", + "MODIFIER_SYMBOL", + "NONSPACING_MARK", + "NUMBER", + "OPEN_PUNCTUATION", + "OTHER", + "OTHER_LETTER", + "OTHER_NUMBER", + "OTHER_PUNCTUATION", + "OTHER_SYMBOL", + "PARAGRAPH_SEPARATOR", + "PRIVATE_USE", + "PUNCTUATION", + "SEPARATOR", + "SPACE_SEPARATOR", + "SPACING_MARK", + "SURROGATE", + "SYMBOL", + "TITLECASE_LETTER", + "UNASSIGNED", + "UPPERCASE_LETTER", +]; diff --git a/vendor/pest_meta/src/optimizer/concatenator.rs b/vendor/pest_meta/src/optimizer/concatenator.rs new file mode 100644 index 000000000..e0aab7bc1 --- /dev/null +++ b/vendor/pest_meta/src/optimizer/concatenator.rs @@ -0,0 +1,34 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use ast::*; + +pub fn concatenate(rule: Rule) -> Rule { + match rule { + Rule { name, ty, expr } => Rule { + name, + ty, + expr: expr.map_bottom_up(|expr| { + if ty == RuleType::Atomic { + // TODO: Use box syntax when it gets stabilized. + match expr { + Expr::Seq(lhs, rhs) => match (*lhs, *rhs) { + (Expr::Str(lhs), Expr::Str(rhs)) => Expr::Str(lhs + &rhs), + (Expr::Insens(lhs), Expr::Insens(rhs)) => Expr::Insens(lhs + &rhs), + (lhs, rhs) => Expr::Seq(Box::new(lhs), Box::new(rhs)), + }, + expr => expr, + } + } else { + expr + } + }), + }, + } +} diff --git a/vendor/pest_meta/src/optimizer/factorizer.rs b/vendor/pest_meta/src/optimizer/factorizer.rs new file mode 100644 index 000000000..236289e14 --- /dev/null +++ b/vendor/pest_meta/src/optimizer/factorizer.rs @@ -0,0 +1,38 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use ast::*; + +pub fn factor(rule: Rule) -> Rule { + match rule { + Rule { name, ty, expr } => Rule { + name, + ty, + expr: expr.map_top_down(|expr| { + // TODO: Use box syntax when it gets stabilized. + match expr { + Expr::Choice(lhs, rhs) => match (*lhs, *rhs) { + (Expr::Seq(l1, r1), Expr::Seq(l2, r2)) => { + if l1 == l2 { + Expr::Seq(l1, Box::new(Expr::Choice(r1, r2))) + } else { + Expr::Choice( + Box::new(Expr::Seq(l1, r1)), + Box::new(Expr::Seq(l2, r2)), + ) + } + } + (lhs, rhs) => Expr::Choice(Box::new(lhs), Box::new(rhs)), + }, + expr => expr, + } + }), + }, + } +} diff --git a/vendor/pest_meta/src/optimizer/mod.rs b/vendor/pest_meta/src/optimizer/mod.rs new file mode 100644 index 000000000..7013c43f9 --- /dev/null +++ b/vendor/pest_meta/src/optimizer/mod.rs @@ -0,0 +1,510 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use ast::*; +use std::collections::HashMap; + +#[cfg(test)] +macro_rules! box_tree { + ( $node:ident( $( $child:ident( $($args:tt)* ) ),+ ) ) => ( + $node ( $( Box::new( box_tree!( $child ( $($args )* ) ) ) ),+ ) + ); + ($expr:expr) => ($expr); +} + +mod concatenator; +mod factorizer; +mod restorer; +mod rotater; +mod skipper; +mod unroller; + +pub fn optimize(rules: Vec<Rule>) -> Vec<OptimizedRule> { + let optimized: Vec<OptimizedRule> = rules + .into_iter() + .map(rotater::rotate) + .map(skipper::skip) + .map(unroller::unroll) + .map(concatenator::concatenate) + .map(factorizer::factor) + .map(rule_to_optimized_rule) + .collect(); + + let rules = to_hash_map(&optimized); + optimized + .into_iter() + .map(|rule| restorer::restore_on_err(rule, &rules)) + .collect() +} + +fn rule_to_optimized_rule(rule: Rule) -> OptimizedRule { + fn to_optimized(expr: Expr) -> OptimizedExpr { + match expr { + Expr::Str(string) => OptimizedExpr::Str(string), + Expr::Insens(string) => OptimizedExpr::Insens(string), + Expr::Range(start, end) => OptimizedExpr::Range(start, end), + Expr::Ident(ident) => OptimizedExpr::Ident(ident), + Expr::PeekSlice(start, end) => OptimizedExpr::PeekSlice(start, end), + Expr::PosPred(expr) => OptimizedExpr::PosPred(Box::new(to_optimized(*expr))), + Expr::NegPred(expr) => OptimizedExpr::NegPred(Box::new(to_optimized(*expr))), + Expr::Seq(lhs, rhs) => { + OptimizedExpr::Seq(Box::new(to_optimized(*lhs)), Box::new(to_optimized(*rhs))) + } + Expr::Choice(lhs, rhs) => { + OptimizedExpr::Choice(Box::new(to_optimized(*lhs)), Box::new(to_optimized(*rhs))) + } + Expr::Opt(expr) => OptimizedExpr::Opt(Box::new(to_optimized(*expr))), + Expr::Rep(expr) => OptimizedExpr::Rep(Box::new(to_optimized(*expr))), + Expr::Skip(strings) => OptimizedExpr::Skip(strings), + Expr::Push(expr) => OptimizedExpr::Push(Box::new(to_optimized(*expr))), + Expr::RepOnce(_) + | Expr::RepExact(..) + | Expr::RepMin(..) + | Expr::RepMax(..) + | Expr::RepMinMax(..) => unreachable!("No valid transformation to OptimizedRule"), + } + } + + OptimizedRule { + name: rule.name, + ty: rule.ty, + expr: to_optimized(rule.expr), + } +} + +fn to_hash_map(rules: &[OptimizedRule]) -> HashMap<String, OptimizedExpr> { + rules + .iter() + .map(|r| (r.name.clone(), r.expr.clone())) + .collect() +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct OptimizedRule { + pub name: String, + pub ty: RuleType, + pub expr: OptimizedExpr, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum OptimizedExpr { + Str(String), + Insens(String), + Range(String, String), + Ident(String), + PeekSlice(i32, Option<i32>), + PosPred(Box<OptimizedExpr>), + NegPred(Box<OptimizedExpr>), + Seq(Box<OptimizedExpr>, Box<OptimizedExpr>), + Choice(Box<OptimizedExpr>, Box<OptimizedExpr>), + Opt(Box<OptimizedExpr>), + Rep(Box<OptimizedExpr>), + Skip(Vec<String>), + Push(Box<OptimizedExpr>), + RestoreOnErr(Box<OptimizedExpr>), +} + +impl OptimizedExpr { + pub fn iter_top_down(&self) -> OptimizedExprTopDownIterator { + OptimizedExprTopDownIterator::new(self) + } + + pub fn map_top_down<F>(self, mut f: F) -> OptimizedExpr + where + F: FnMut(OptimizedExpr) -> OptimizedExpr, + { + fn map_internal<F>(expr: OptimizedExpr, f: &mut F) -> OptimizedExpr + where + F: FnMut(OptimizedExpr) -> OptimizedExpr, + { + let expr = f(expr); + + match expr { + // TODO: Use box syntax when it gets stabilized. + OptimizedExpr::PosPred(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::PosPred(mapped) + } + OptimizedExpr::NegPred(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::NegPred(mapped) + } + OptimizedExpr::Seq(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + OptimizedExpr::Seq(mapped_lhs, mapped_rhs) + } + OptimizedExpr::Choice(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + OptimizedExpr::Choice(mapped_lhs, mapped_rhs) + } + OptimizedExpr::Rep(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::Rep(mapped) + } + OptimizedExpr::Opt(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::Opt(mapped) + } + OptimizedExpr::Push(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::Push(mapped) + } + expr => expr, + } + } + + map_internal(self, &mut f) + } + + pub fn map_bottom_up<F>(self, mut f: F) -> OptimizedExpr + where + F: FnMut(OptimizedExpr) -> OptimizedExpr, + { + fn map_internal<F>(expr: OptimizedExpr, f: &mut F) -> OptimizedExpr + where + F: FnMut(OptimizedExpr) -> OptimizedExpr, + { + let mapped = match expr { + OptimizedExpr::PosPred(expr) => { + // TODO: Use box syntax when it gets stabilized. + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::PosPred(mapped) + } + OptimizedExpr::NegPred(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::NegPred(mapped) + } + OptimizedExpr::Seq(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + OptimizedExpr::Seq(mapped_lhs, mapped_rhs) + } + OptimizedExpr::Choice(lhs, rhs) => { + let mapped_lhs = Box::new(map_internal(*lhs, f)); + let mapped_rhs = Box::new(map_internal(*rhs, f)); + OptimizedExpr::Choice(mapped_lhs, mapped_rhs) + } + OptimizedExpr::Rep(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::Rep(mapped) + } + OptimizedExpr::Opt(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::Opt(mapped) + } + OptimizedExpr::Push(expr) => { + let mapped = Box::new(map_internal(*expr, f)); + OptimizedExpr::Push(mapped) + } + expr => expr, + }; + + f(mapped) + } + + map_internal(self, &mut f) + } +} + +pub struct OptimizedExprTopDownIterator { + current: Option<OptimizedExpr>, + next: Option<OptimizedExpr>, + right_branches: Vec<OptimizedExpr>, +} + +impl OptimizedExprTopDownIterator { + pub fn new(expr: &OptimizedExpr) -> Self { + let mut iter = OptimizedExprTopDownIterator { + current: None, + next: None, + right_branches: vec![], + }; + iter.iterate_expr(expr.clone()); + iter + } + + fn iterate_expr(&mut self, expr: OptimizedExpr) { + self.current = Some(expr.clone()); + match expr { + OptimizedExpr::Seq(lhs, rhs) => { + self.right_branches.push(*rhs); + self.next = Some(*lhs); + } + OptimizedExpr::Choice(lhs, rhs) => { + self.right_branches.push(*rhs); + self.next = Some(*lhs); + } + OptimizedExpr::PosPred(expr) + | OptimizedExpr::NegPred(expr) + | OptimizedExpr::Rep(expr) + | OptimizedExpr::Opt(expr) + | OptimizedExpr::Push(expr) => { + self.next = Some(*expr); + } + _ => { + self.next = None; + } + } + } +} + +impl Iterator for OptimizedExprTopDownIterator { + type Item = OptimizedExpr; + + fn next(&mut self) -> Option<Self::Item> { + let result = self.current.take(); + + if let Some(expr) = self.next.take() { + self.iterate_expr(expr); + } else if let Some(expr) = self.right_branches.pop() { + self.iterate_expr(expr); + } + + result + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rotate() { + let rules = { + use ast::Expr::*; + vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Choice( + Choice( + Choice(Str(String::from("a")), Str(String::from("b"))), + Str(String::from("c")) + ), + Str(String::from("d")) + )), + }] + }; + let rotated = { + use optimizer::OptimizedExpr::*; + vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Choice( + Str(String::from("a")), + Choice( + Str(String::from("b")), + Choice(Str(String::from("c")), Str(String::from("d"))) + ) + )), + }] + }; + + assert_eq!(optimize(rules), rotated); + } + + #[test] + fn skip() { + let rules = { + use ast::Expr::*; + vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: box_tree!(Rep(Seq( + NegPred(Choice(Str(String::from("a")), Str(String::from("b")))), + Ident(String::from("ANY")) + ))), + }] + }; + let skipped = vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: OptimizedExpr::Skip(vec![String::from("a"), String::from("b")]), + }]; + + assert_eq!(optimize(rules), skipped); + } + + #[test] + fn concat_strings() { + let rules = { + use ast::Expr::*; + vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: box_tree!(Seq( + Seq(Str(String::from("a")), Str(String::from("b"))), + Seq(Str(String::from("c")), Str(String::from("d"))) + )), + }] + }; + let concatenated = vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: OptimizedExpr::Str(String::from("abcd")), + }]; + + assert_eq!(optimize(rules), concatenated); + } + + #[test] + fn unroll_loop_exact() { + let rules = vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: Expr::RepExact(Box::new(Expr::Ident(String::from("a"))), 3), + }]; + let unrolled = { + use optimizer::OptimizedExpr::*; + vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: box_tree!(Seq( + Ident(String::from("a")), + Seq(Ident(String::from("a")), Ident(String::from("a"))) + )), + }] + }; + + assert_eq!(optimize(rules), unrolled); + } + + #[test] + fn unroll_loop_max() { + let rules = vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: Expr::RepMax(Box::new(Expr::Str("a".to_owned())), 3), + }]; + let unrolled = { + use optimizer::OptimizedExpr::*; + vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: box_tree!(Seq( + Opt(Str(String::from("a"))), + Seq(Opt(Str(String::from("a"))), Opt(Str(String::from("a")))) + )), + }] + }; + + assert_eq!(optimize(rules), unrolled); + } + + #[test] + fn unroll_loop_min() { + let rules = vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: Expr::RepMin(Box::new(Expr::Str("a".to_owned())), 2), + }]; + let unrolled = { + use optimizer::OptimizedExpr::*; + vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: box_tree!(Seq( + Str(String::from("a")), + Seq(Str(String::from("a")), Rep(Str(String::from("a")))) + )), + }] + }; + + assert_eq!(optimize(rules), unrolled); + } + + #[test] + fn unroll_loop_min_max() { + let rules = vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: Expr::RepMinMax(Box::new(Expr::Str("a".to_owned())), 2, 3), + }]; + let unrolled = { + use optimizer::OptimizedExpr::*; + vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + /* TODO possible room for improvement here: + * if the sequences were rolled out in the opposite + * order, we could further optimize the strings + * in cases like this. + Str(String::from(("aa")), + Opt(Str(String::from("a"))) + */ + expr: box_tree!(Seq( + Str(String::from("a")), + Seq(Str(String::from("a")), Opt(Str(String::from("a")))) + )), + }] + }; + + assert_eq!(optimize(rules), unrolled); + } + + #[test] + fn concat_insensitive_strings() { + let rules = { + use ast::Expr::*; + vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: box_tree!(Seq( + Seq(Insens(String::from("a")), Insens(String::from("b"))), + Seq(Insens(String::from("c")), Insens(String::from("d"))) + )), + }] + }; + let concatenated = vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Atomic, + expr: OptimizedExpr::Insens(String::from("abcd")), + }]; + + assert_eq!(optimize(rules), concatenated); + } + + #[test] + fn long_common_sequence() { + let rules = { + use ast::Expr::*; + vec![Rule { + name: "rule".to_owned(), + ty: RuleType::Silent, + expr: box_tree!(Choice( + Seq( + Ident(String::from("a")), + Seq(Ident(String::from("b")), Ident(String::from("c"))) + ), + Seq( + Seq(Ident(String::from("a")), Ident(String::from("b"))), + Ident(String::from("d")) + ) + )), + }] + }; + let optimized = { + use optimizer::OptimizedExpr::*; + vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Silent, + expr: box_tree!(Seq( + Ident(String::from("a")), + Seq( + Ident(String::from("b")), + Choice(Ident(String::from("c")), Ident(String::from("d"))) + ) + )), + }] + }; + + assert_eq!(optimize(rules), optimized); + } +} diff --git a/vendor/pest_meta/src/optimizer/restorer.rs b/vendor/pest_meta/src/optimizer/restorer.rs new file mode 100644 index 000000000..34a710eab --- /dev/null +++ b/vendor/pest_meta/src/optimizer/restorer.rs @@ -0,0 +1,157 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. +use std::collections::HashMap; + +use optimizer::*; + +pub fn restore_on_err( + rule: OptimizedRule, + rules: &HashMap<String, OptimizedExpr>, +) -> OptimizedRule { + match rule { + OptimizedRule { name, ty, expr } => { + let expr = expr.map_bottom_up(|expr| wrap_branching_exprs(expr, rules)); + + OptimizedRule { name, ty, expr } + } + } +} + +fn wrap_branching_exprs( + expr: OptimizedExpr, + rules: &HashMap<String, OptimizedExpr>, +) -> OptimizedExpr { + match expr { + OptimizedExpr::Opt(expr) => { + if child_modifies_state(&expr, rules, &mut HashMap::new()) { + OptimizedExpr::Opt(Box::new(OptimizedExpr::RestoreOnErr(expr))) + } else { + OptimizedExpr::Opt(expr) + } + } + OptimizedExpr::Choice(lhs, rhs) => { + let wrapped_lhs = if child_modifies_state(&lhs, rules, &mut HashMap::new()) { + Box::new(OptimizedExpr::RestoreOnErr(lhs)) + } else { + lhs + }; + let wrapped_rhs = if child_modifies_state(&rhs, rules, &mut HashMap::new()) { + Box::new(OptimizedExpr::RestoreOnErr(rhs)) + } else { + rhs + }; + OptimizedExpr::Choice(wrapped_lhs, wrapped_rhs) + } + OptimizedExpr::Rep(expr) => { + if child_modifies_state(&expr, rules, &mut HashMap::new()) { + OptimizedExpr::Rep(Box::new(OptimizedExpr::RestoreOnErr(expr))) + } else { + OptimizedExpr::Rep(expr) + } + } + _ => expr, + } +} + +fn child_modifies_state( + expr: &OptimizedExpr, + rules: &HashMap<String, OptimizedExpr>, + cache: &mut HashMap<String, Option<bool>>, +) -> bool { + expr.iter_top_down().any(|expr| match expr { + OptimizedExpr::Push(_) => true, + OptimizedExpr::Ident(ref name) if name == "DROP" => true, + OptimizedExpr::Ident(ref name) if name == "POP" => true, + OptimizedExpr::Ident(ref name) => match cache.get(name).cloned() { + Some(option) => match option { + Some(cached) => cached, + None => { + cache.insert(name.to_owned(), Some(false)); + false + } + }, + None => { + cache.insert(name.to_owned(), None); + + let result = match rules.get(name) { + Some(expr) => child_modifies_state(expr, rules, cache), + None => false, + }; + + cache.insert(name.to_owned(), Some(result)); + + result + } + }, + _ => false, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use optimizer::OptimizedExpr::*; + + #[test] + fn restore_no_stack_children() { + let rules = vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Opt(Str("a".to_string()))), + }]; + + assert_eq!( + restore_on_err(rules[0].clone(), &to_hash_map(&rules)), + rules[0].clone() + ); + } + + #[test] + fn restore_with_child_stack_ops() { + let rules = vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Rep(Push(Str("a".to_string())))), + }]; + + let restored = OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Rep(RestoreOnErr(Push(Str("a".to_string()))))), + }; + + assert_eq!( + restore_on_err(rules[0].clone(), &to_hash_map(&rules)), + restored + ); + } + + #[test] + fn restore_choice_branch_with_and_branch_without() { + let rules = vec![OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Choice(Push(Str("a".to_string())), Str("a".to_string()))), + }]; + + let restored = OptimizedRule { + name: "rule".to_owned(), + ty: RuleType::Normal, + expr: box_tree!(Choice( + RestoreOnErr(Push(Str("a".to_string()))), + Str("a".to_string()) + )), + }; + + assert_eq!( + restore_on_err(rules[0].clone(), &to_hash_map(&rules)), + restored + ); + } +} diff --git a/vendor/pest_meta/src/optimizer/rotater.rs b/vendor/pest_meta/src/optimizer/rotater.rs new file mode 100644 index 000000000..3588738ad --- /dev/null +++ b/vendor/pest_meta/src/optimizer/rotater.rs @@ -0,0 +1,45 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use ast::*; + +pub fn rotate(rule: Rule) -> Rule { + fn rotate_internal(expr: Expr) -> Expr { + match expr { + // TODO: Use box syntax when it gets stabilized. + Expr::Seq(lhs, rhs) => { + let lhs = *lhs; + match lhs { + Expr::Seq(ll, lr) => { + rotate_internal(Expr::Seq(ll, Box::new(Expr::Seq(lr, rhs)))) + } + lhs => Expr::Seq(Box::new(lhs), rhs), + } + } + Expr::Choice(lhs, rhs) => { + let lhs = *lhs; + match lhs { + Expr::Choice(ll, lr) => { + rotate_internal(Expr::Choice(ll, Box::new(Expr::Choice(lr, rhs)))) + } + lhs => Expr::Choice(Box::new(lhs), rhs), + } + } + expr => expr, + } + } + + match rule { + Rule { name, ty, expr } => Rule { + name, + ty, + expr: expr.map_top_down(rotate_internal), + }, + } +} diff --git a/vendor/pest_meta/src/optimizer/skipper.rs b/vendor/pest_meta/src/optimizer/skipper.rs new file mode 100644 index 000000000..f55edc06f --- /dev/null +++ b/vendor/pest_meta/src/optimizer/skipper.rs @@ -0,0 +1,57 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use ast::*; + +pub fn skip(rule: Rule) -> Rule { + fn populate_choices(expr: Expr, mut choices: Vec<String>) -> Option<Expr> { + match expr { + Expr::Choice(lhs, rhs) => { + if let Expr::Str(string) = *lhs { + choices.push(string); + populate_choices(*rhs, choices) + } else { + None + } + } + Expr::Str(string) => { + choices.push(string); + Some(Expr::Skip(choices)) + } + _ => None, + } + } + + match rule { + Rule { name, ty, expr } => Rule { + name, + ty, + expr: if ty == RuleType::Atomic { + expr.map_top_down(|expr| { + // TODO: Use box syntax when it gets stabilized. + if let Expr::Rep(expr) = expr.clone() { + if let Expr::Seq(lhs, rhs) = *expr.clone() { + if let (Expr::NegPred(expr), Expr::Ident(ident)) = (*lhs, *rhs) { + if ident == "ANY" { + if let Some(expr) = populate_choices(*expr, vec![]) { + return expr; + } + } + } + } + }; + + expr + }) + } else { + expr + }, + }, + } +} diff --git a/vendor/pest_meta/src/optimizer/unroller.rs b/vendor/pest_meta/src/optimizer/unroller.rs new file mode 100644 index 000000000..fff17336d --- /dev/null +++ b/vendor/pest_meta/src/optimizer/unroller.rs @@ -0,0 +1,67 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use ast::*; + +pub fn unroll(rule: Rule) -> Rule { + match rule { + Rule { name, ty, expr } => Rule { + name, + ty, + expr: expr.map_bottom_up(|expr| match expr { + Expr::RepOnce(expr) => Expr::Seq(expr.clone(), Box::new(Expr::Rep(expr))), + Expr::RepExact(expr, num) => (1..num + 1) + .map(|_| *expr.clone()) + .rev() + .fold(None, |rep, expr| match rep { + None => Some(expr), + Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))), + }) + .unwrap(), + Expr::RepMin(expr, min) => (1..min + 2) + .map(|i| { + if i <= min { + *expr.clone() + } else { + Expr::Rep(expr.clone()) + } + }) + .rev() + .fold(None, |rep, expr| match rep { + None => Some(expr), + Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))), + }) + .unwrap(), + Expr::RepMax(expr, max) => (1..max + 1) + .map(|_| Expr::Opt(expr.clone())) + .rev() + .fold(None, |rep, expr| match rep { + None => Some(expr), + Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))), + }) + .unwrap(), + Expr::RepMinMax(expr, min, max) => (1..max + 1) + .map(|i| { + if i <= min { + *expr.clone() + } else { + Expr::Opt(expr.clone()) + } + }) + .rev() + .fold(None, |rep, expr| match rep { + None => Some(expr), + Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))), + }) + .unwrap(), + expr => expr, + }), + }, + } +} diff --git a/vendor/pest_meta/src/parser.rs b/vendor/pest_meta/src/parser.rs new file mode 100644 index 000000000..5f6f3b374 --- /dev/null +++ b/vendor/pest_meta/src/parser.rs @@ -0,0 +1,1488 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::char; +use std::iter::Peekable; + +use pest::error::{Error, ErrorVariant}; +use pest::iterators::{Pair, Pairs}; +use pest::prec_climber::{Assoc, Operator, PrecClimber}; +use pest::{Parser, Span}; + +use ast::{Expr, Rule as AstRule, RuleType}; +use validator; + +include!("grammar.rs"); + +pub fn parse(rule: Rule, data: &str) -> Result<Pairs<Rule>, Error<Rule>> { + PestParser::parse(rule, data) +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct ParserRule<'i> { + pub name: String, + pub span: Span<'i>, + pub ty: RuleType, + pub node: ParserNode<'i>, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct ParserNode<'i> { + pub expr: ParserExpr<'i>, + pub span: Span<'i>, +} + +impl<'i> ParserNode<'i> { + pub fn filter_map_top_down<F, T>(self, mut f: F) -> Vec<T> + where + F: FnMut(ParserNode<'i>) -> Option<T>, + { + pub fn filter_internal<'i, F, T>(node: ParserNode<'i>, f: &mut F, result: &mut Vec<T>) + where + F: FnMut(ParserNode<'i>) -> Option<T>, + { + if let Some(value) = f(node.clone()) { + result.push(value); + } + + match node.expr { + // TODO: Use box syntax when it gets stabilized. + ParserExpr::PosPred(node) => { + filter_internal(*node, f, result); + } + ParserExpr::NegPred(node) => { + filter_internal(*node, f, result); + } + ParserExpr::Seq(lhs, rhs) => { + filter_internal(*lhs, f, result); + filter_internal(*rhs, f, result); + } + ParserExpr::Choice(lhs, rhs) => { + filter_internal(*lhs, f, result); + filter_internal(*rhs, f, result); + } + ParserExpr::Rep(node) => { + filter_internal(*node, f, result); + } + ParserExpr::RepOnce(node) => { + filter_internal(*node, f, result); + } + ParserExpr::RepExact(node, _) => { + filter_internal(*node, f, result); + } + ParserExpr::RepMin(node, _) => { + filter_internal(*node, f, result); + } + ParserExpr::RepMax(node, _) => { + filter_internal(*node, f, result); + } + ParserExpr::RepMinMax(node, ..) => { + filter_internal(*node, f, result); + } + ParserExpr::Opt(node) => { + filter_internal(*node, f, result); + } + ParserExpr::Push(node) => { + filter_internal(*node, f, result); + } + _ => (), + } + } + + let mut result = vec![]; + + filter_internal(self, &mut f, &mut result); + + result + } +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ParserExpr<'i> { + Str(String), + Insens(String), + Range(String, String), + Ident(String), + PeekSlice(i32, Option<i32>), + PosPred(Box<ParserNode<'i>>), + NegPred(Box<ParserNode<'i>>), + Seq(Box<ParserNode<'i>>, Box<ParserNode<'i>>), + Choice(Box<ParserNode<'i>>, Box<ParserNode<'i>>), + Opt(Box<ParserNode<'i>>), + Rep(Box<ParserNode<'i>>), + RepOnce(Box<ParserNode<'i>>), + RepExact(Box<ParserNode<'i>>, u32), + RepMin(Box<ParserNode<'i>>, u32), + RepMax(Box<ParserNode<'i>>, u32), + RepMinMax(Box<ParserNode<'i>>, u32, u32), + Push(Box<ParserNode<'i>>), +} + +fn convert_rule(rule: ParserRule) -> AstRule { + match rule { + ParserRule { name, ty, node, .. } => { + let expr = convert_node(node); + + AstRule { name, ty, expr } + } + } +} + +fn convert_node(node: ParserNode) -> Expr { + match node.expr { + ParserExpr::Str(string) => Expr::Str(string), + ParserExpr::Insens(string) => Expr::Insens(string), + ParserExpr::Range(start, end) => Expr::Range(start, end), + ParserExpr::Ident(ident) => Expr::Ident(ident), + ParserExpr::PeekSlice(start, end) => Expr::PeekSlice(start, end), + ParserExpr::PosPred(node) => Expr::PosPred(Box::new(convert_node(*node))), + ParserExpr::NegPred(node) => Expr::NegPred(Box::new(convert_node(*node))), + ParserExpr::Seq(node1, node2) => Expr::Seq( + Box::new(convert_node(*node1)), + Box::new(convert_node(*node2)), + ), + ParserExpr::Choice(node1, node2) => Expr::Choice( + Box::new(convert_node(*node1)), + Box::new(convert_node(*node2)), + ), + ParserExpr::Opt(node) => Expr::Opt(Box::new(convert_node(*node))), + ParserExpr::Rep(node) => Expr::Rep(Box::new(convert_node(*node))), + ParserExpr::RepOnce(node) => Expr::RepOnce(Box::new(convert_node(*node))), + ParserExpr::RepExact(node, num) => Expr::RepExact(Box::new(convert_node(*node)), num), + ParserExpr::RepMin(node, max) => Expr::RepMin(Box::new(convert_node(*node)), max), + ParserExpr::RepMax(node, max) => Expr::RepMax(Box::new(convert_node(*node)), max), + ParserExpr::RepMinMax(node, min, max) => { + Expr::RepMinMax(Box::new(convert_node(*node)), min, max) + } + ParserExpr::Push(node) => Expr::Push(Box::new(convert_node(*node))), + } +} + +pub fn consume_rules(pairs: Pairs<Rule>) -> Result<Vec<AstRule>, Vec<Error<Rule>>> { + let rules = consume_rules_with_spans(pairs)?; + let errors = validator::validate_ast(&rules); + if errors.is_empty() { + Ok(rules.into_iter().map(convert_rule).collect()) + } else { + Err(errors) + } +} + +fn consume_rules_with_spans<'i>( + pairs: Pairs<'i, Rule>, +) -> Result<Vec<ParserRule<'i>>, Vec<Error<Rule>>> { + let climber = PrecClimber::new(vec![ + Operator::new(Rule::choice_operator, Assoc::Left), + Operator::new(Rule::sequence_operator, Assoc::Left), + ]); + + pairs + .filter(|pair| pair.as_rule() == Rule::grammar_rule) + .map(|pair| { + let mut pairs = pair.into_inner().peekable(); + + let span = pairs.next().unwrap().as_span(); + let name = span.as_str().to_owned(); + + pairs.next().unwrap(); // assignment_operator + + let ty = if pairs.peek().unwrap().as_rule() != Rule::opening_brace { + match pairs.next().unwrap().as_rule() { + Rule::silent_modifier => RuleType::Silent, + Rule::atomic_modifier => RuleType::Atomic, + Rule::compound_atomic_modifier => RuleType::CompoundAtomic, + Rule::non_atomic_modifier => RuleType::NonAtomic, + _ => unreachable!(), + } + } else { + RuleType::Normal + }; + + pairs.next().unwrap(); // opening_brace + + let node = consume_expr(pairs.next().unwrap().into_inner().peekable(), &climber)?; + + Ok(ParserRule { + name, + span, + ty, + node, + }) + }) + .collect() +} + +fn consume_expr<'i>( + pairs: Peekable<Pairs<'i, Rule>>, + climber: &PrecClimber<Rule>, +) -> Result<ParserNode<'i>, Vec<Error<Rule>>> { + fn unaries<'i>( + mut pairs: Peekable<Pairs<'i, Rule>>, + climber: &PrecClimber<Rule>, + ) -> Result<ParserNode<'i>, Vec<Error<Rule>>> { + let pair = pairs.next().unwrap(); + + let node = match pair.as_rule() { + Rule::opening_paren => { + let node = unaries(pairs, climber)?; + let end = node.span.end_pos(); + + ParserNode { + expr: node.expr, + span: pair.as_span().start_pos().span(&end), + } + } + Rule::positive_predicate_operator => { + let node = unaries(pairs, climber)?; + let end = node.span.end_pos(); + + ParserNode { + expr: ParserExpr::PosPred(Box::new(node)), + span: pair.as_span().start_pos().span(&end), + } + } + Rule::negative_predicate_operator => { + let node = unaries(pairs, climber)?; + let end = node.span.end_pos(); + + ParserNode { + expr: ParserExpr::NegPred(Box::new(node)), + span: pair.as_span().start_pos().span(&end), + } + } + other_rule => { + let node = match other_rule { + Rule::expression => consume_expr(pair.into_inner().peekable(), climber)?, + Rule::_push => { + let start = pair.clone().as_span().start_pos(); + let mut pairs = pair.into_inner(); + pairs.next().unwrap(); // opening_paren + let pair = pairs.next().unwrap(); + + let node = consume_expr(pair.into_inner().peekable(), climber)?; + let end = node.span.end_pos(); + + ParserNode { + expr: ParserExpr::Push(Box::new(node)), + span: start.span(&end), + } + } + Rule::peek_slice => { + let mut pairs = pair.clone().into_inner(); + pairs.next().unwrap(); // opening_brack + let pair_start = pairs.next().unwrap(); // .. or integer + let start: i32 = match pair_start.as_rule() { + Rule::range_operator => 0, + Rule::integer => { + pairs.next().unwrap(); // .. + pair_start.as_str().parse().unwrap() + } + _ => unreachable!(), + }; + let pair_end = pairs.next().unwrap(); // integer or } + let end: Option<i32> = match pair_end.as_rule() { + Rule::closing_brack => None, + Rule::integer => { + pairs.next().unwrap(); // } + Some(pair_end.as_str().parse().unwrap()) + } + _ => unreachable!(), + }; + ParserNode { + expr: ParserExpr::PeekSlice(start, end), + span: pair.as_span(), + } + } + Rule::identifier => ParserNode { + expr: ParserExpr::Ident(pair.as_str().to_owned()), + span: pair.clone().as_span(), + }, + Rule::string => { + let string = unescape(pair.as_str()).expect("incorrect string literal"); + ParserNode { + expr: ParserExpr::Str(string[1..string.len() - 1].to_owned()), + span: pair.clone().as_span(), + } + } + Rule::insensitive_string => { + let string = unescape(pair.as_str()).expect("incorrect string literal"); + ParserNode { + expr: ParserExpr::Insens(string[2..string.len() - 1].to_owned()), + span: pair.clone().as_span(), + } + } + Rule::range => { + let mut pairs = pair.into_inner(); + let pair = pairs.next().unwrap(); + let start = unescape(pair.as_str()).expect("incorrect char literal"); + let start_pos = pair.clone().as_span().start_pos(); + pairs.next(); + let pair = pairs.next().unwrap(); + let end = unescape(pair.as_str()).expect("incorrect char literal"); + let end_pos = pair.clone().as_span().end_pos(); + + ParserNode { + expr: ParserExpr::Range( + start[1..start.len() - 1].to_owned(), + end[1..end.len() - 1].to_owned(), + ), + span: start_pos.span(&end_pos), + } + } + _ => unreachable!(), + }; + + pairs.fold( + Ok(node), + |node: Result<ParserNode<'i>, Vec<Error<Rule>>>, pair| { + let node = node?; + + let node = match pair.as_rule() { + Rule::optional_operator => { + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::Opt(Box::new(node)), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::repeat_operator => { + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::Rep(Box::new(node)), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::repeat_once_operator => { + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::RepOnce(Box::new(node)), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::repeat_exact => { + let mut inner = pair.clone().into_inner(); + + inner.next().unwrap(); // opening_brace + + let number = inner.next().unwrap(); + let num = if let Ok(num) = number.as_str().parse::<u32>() { + num + } else { + return Err(vec![Error::new_from_span( + ErrorVariant::CustomError { + message: "number cannot overflow u32".to_owned(), + }, + number.as_span(), + )]); + }; + + if num == 0 { + let error: Error<Rule> = Error::new_from_span( + ErrorVariant::CustomError { + message: "cannot repeat 0 times".to_owned(), + }, + number.as_span(), + ); + + return Err(vec![error]); + } + + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::RepExact(Box::new(node), num), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::repeat_min => { + let mut inner = pair.clone().into_inner(); + + inner.next().unwrap(); // opening_brace + + let min_number = inner.next().unwrap(); + let min = if let Ok(min) = min_number.as_str().parse::<u32>() { + min + } else { + return Err(vec![Error::new_from_span( + ErrorVariant::CustomError { + message: "number cannot overflow u32".to_owned(), + }, + min_number.as_span(), + )]); + }; + + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::RepMin(Box::new(node), min), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::repeat_max => { + let mut inner = pair.clone().into_inner(); + + inner.next().unwrap(); // opening_brace + inner.next().unwrap(); // comma + + let max_number = inner.next().unwrap(); + let max = if let Ok(max) = max_number.as_str().parse::<u32>() { + max + } else { + return Err(vec![Error::new_from_span( + ErrorVariant::CustomError { + message: "number cannot overflow u32".to_owned(), + }, + max_number.as_span(), + )]); + }; + + if max == 0 { + let error: Error<Rule> = Error::new_from_span( + ErrorVariant::CustomError { + message: "cannot repeat 0 times".to_owned(), + }, + max_number.as_span(), + ); + + return Err(vec![error]); + } + + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::RepMax(Box::new(node), max), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::repeat_min_max => { + let mut inner = pair.clone().into_inner(); + + inner.next().unwrap(); // opening_brace + + let min_number = inner.next().unwrap(); + let min = if let Ok(min) = min_number.as_str().parse::<u32>() { + min + } else { + return Err(vec![Error::new_from_span( + ErrorVariant::CustomError { + message: "number cannot overflow u32".to_owned(), + }, + min_number.as_span(), + )]); + }; + + inner.next().unwrap(); // comma + + let max_number = inner.next().unwrap(); + let max = if let Ok(max) = max_number.as_str().parse::<u32>() { + max + } else { + return Err(vec![Error::new_from_span( + ErrorVariant::CustomError { + message: "number cannot overflow u32".to_owned(), + }, + max_number.as_span(), + )]); + }; + + if max == 0 { + let error: Error<Rule> = Error::new_from_span( + ErrorVariant::CustomError { + message: "cannot repeat 0 times".to_owned(), + }, + max_number.as_span(), + ); + + return Err(vec![error]); + } + + let start = node.span.start_pos(); + ParserNode { + expr: ParserExpr::RepMinMax(Box::new(node), min, max), + span: start.span(&pair.as_span().end_pos()), + } + } + Rule::closing_paren => { + let start = node.span.start_pos(); + + ParserNode { + expr: node.expr, + span: start.span(&pair.as_span().end_pos()), + } + } + _ => unreachable!(), + }; + + Ok(node) + }, + )? + } + }; + + Ok(node) + } + + let term = |pair: Pair<'i, Rule>| unaries(pair.into_inner().peekable(), climber); + let infix = |lhs: Result<ParserNode<'i>, Vec<Error<Rule>>>, + op: Pair<'i, Rule>, + rhs: Result<ParserNode<'i>, Vec<Error<Rule>>>| match op.as_rule() { + Rule::sequence_operator => { + let lhs = lhs?; + let rhs = rhs?; + + let start = lhs.span.start_pos(); + let end = rhs.span.end_pos(); + + Ok(ParserNode { + expr: ParserExpr::Seq(Box::new(lhs), Box::new(rhs)), + span: start.span(&end), + }) + } + Rule::choice_operator => { + let lhs = lhs?; + let rhs = rhs?; + + let start = lhs.span.start_pos(); + let end = rhs.span.end_pos(); + + Ok(ParserNode { + expr: ParserExpr::Choice(Box::new(lhs), Box::new(rhs)), + span: start.span(&end), + }) + } + _ => unreachable!(), + }; + + climber.climb(pairs, term, infix) +} + +fn unescape(string: &str) -> Option<String> { + let mut result = String::new(); + let mut chars = string.chars(); + + loop { + match chars.next() { + Some('\\') => match chars.next()? { + '"' => result.push('"'), + '\\' => result.push('\\'), + 'r' => result.push('\r'), + 'n' => result.push('\n'), + 't' => result.push('\t'), + '0' => result.push('\0'), + '\'' => result.push('\''), + 'x' => { + let string: String = chars.clone().take(2).collect(); + + if string.len() != 2 { + return None; + } + + for _ in 0..string.len() { + chars.next()?; + } + + let value = u8::from_str_radix(&string, 16).ok()?; + + result.push(char::from(value)); + } + 'u' => { + if chars.next()? != '{' { + return None; + } + + let string: String = chars.clone().take_while(|c| *c != '}').collect(); + + if string.len() < 2 || 6 < string.len() { + return None; + } + + for _ in 0..string.len() + 1 { + chars.next()?; + } + + let value = u32::from_str_radix(&string, 16).ok()?; + + result.push(char::from_u32(value)?); + } + _ => return None, + }, + Some(c) => result.push(c), + None => return Some(result), + }; + } +} + +#[cfg(test)] +mod tests { + use super::super::unwrap_or_report; + use super::*; + + #[test] + fn rules() { + parses_to! { + parser: PestParser, + input: "a = { b } c = { d }", + rule: Rule::grammar_rules, + tokens: [ + grammar_rule(0, 9, [ + identifier(0, 1), + assignment_operator(2, 3), + opening_brace(4, 5), + expression(6, 8, [ + term(6, 8, [ + identifier(6, 7) + ]) + ]), + closing_brace(8, 9) + ]), + grammar_rule(10, 19, [ + identifier(10, 11), + assignment_operator(12, 13), + opening_brace(14, 15), + expression(16, 18, [ + term(16, 18, [ + identifier(16, 17) + ]) + ]), + closing_brace(18, 19) + ]) + ] + }; + } + + #[test] + fn rule() { + parses_to! { + parser: PestParser, + input: "a = ! { b ~ c }", + rule: Rule::grammar_rule, + tokens: [ + grammar_rule(0, 15, [ + identifier(0, 1), + assignment_operator(2, 3), + non_atomic_modifier(4, 5), + opening_brace(6, 7), + expression(8, 14, [ + term(8, 10, [ + identifier(8, 9) + ]), + sequence_operator(10, 11), + term(12, 14, [ + identifier(12, 13) + ]) + ]), + closing_brace(14, 15) + ]) + ] + }; + } + + #[test] + fn expression() { + parses_to! { + parser: PestParser, + input: "_a | 'a'..'b' ~ !^\"abc\" ~ (d | e)*?", + rule: Rule::expression, + tokens: [ + expression(0, 35, [ + term(0, 3, [ + identifier(0, 2) + ]), + choice_operator(3, 4), + term(5, 14, [ + range(5, 13, [ + character(5, 8, [ + single_quote(5, 6), + inner_chr(6, 7), + single_quote(7, 8) + ]), + range_operator(8, 10), + character(10, 13, [ + single_quote(10, 11), + inner_chr(11, 12), + single_quote(12, 13) + ]) + ]) + ]), + sequence_operator(14, 15), + term(16, 24, [ + negative_predicate_operator(16, 17), + insensitive_string(17, 23, [ + string(18, 23, [ + quote(18, 19), + inner_str(19, 22), + quote(22, 23) + ]) + ]) + ]), + sequence_operator(24, 25), + term(26, 35, [ + opening_paren(26, 27), + expression(27, 32, [ + term(27, 29, [ + identifier(27, 28) + ]), + choice_operator(29, 30), + term(31, 32, [ + identifier(31, 32) + ]) + ]), + closing_paren(32, 33), + repeat_operator(33, 34), + optional_operator(34, 35) + ]) + ]) + ] + }; + } + + #[test] + fn repeat_exact() { + parses_to! { + parser: PestParser, + input: "{1}", + rule: Rule::repeat_exact, + tokens: [ + repeat_exact(0, 3, [ + opening_brace(0, 1), + number(1, 2), + closing_brace(2, 3) + ]) + ] + }; + } + + #[test] + fn repeat_min() { + parses_to! { + parser: PestParser, + input: "{2,}", + rule: Rule::repeat_min, + tokens: [ + repeat_min(0, 4, [ + opening_brace(0,1), + number(1,2), + comma(2,3), + closing_brace(3,4) + ]) + ] + } + } + + #[test] + fn repeat_max() { + parses_to! { + parser: PestParser, + input: "{, 3}", + rule: Rule::repeat_max, + tokens: [ + repeat_max(0, 5, [ + opening_brace(0,1), + comma(1,2), + number(3,4), + closing_brace(4,5) + ]) + ] + } + } + + #[test] + fn repeat_min_max() { + parses_to! { + parser: PestParser, + input: "{1, 2}", + rule: Rule::repeat_min_max, + tokens: [ + repeat_min_max(0, 6, [ + opening_brace(0, 1), + number(1, 2), + comma(2, 3), + number(4, 5), + closing_brace(5, 6) + ]) + ] + }; + } + + #[test] + fn push() { + parses_to! { + parser: PestParser, + input: "PUSH ( a )", + rule: Rule::_push, + tokens: [ + _push(0, 10, [ + opening_paren(5, 6), + expression(7, 9, [ + term(7, 9, [ + identifier(7, 8) + ]) + ]), + closing_paren(9, 10) + ]) + ] + }; + } + + #[test] + fn peek_slice_all() { + parses_to! { + parser: PestParser, + input: "PEEK[..]", + rule: Rule::peek_slice, + tokens: [ + peek_slice(0, 8, [ + opening_brack(4, 5), + range_operator(5, 7), + closing_brack(7, 8) + ]) + ] + }; + } + + #[test] + fn peek_slice_start() { + parses_to! { + parser: PestParser, + input: "PEEK[1..]", + rule: Rule::peek_slice, + tokens: [ + peek_slice(0, 9, [ + opening_brack(4, 5), + integer(5, 6), + range_operator(6, 8), + closing_brack(8, 9) + ]) + ] + }; + } + + #[test] + fn peek_slice_end() { + parses_to! { + parser: PestParser, + input: "PEEK[ ..-1]", + rule: Rule::peek_slice, + tokens: [ + peek_slice(0, 11, [ + opening_brack(4, 5), + range_operator(6, 8), + integer(8, 10), + closing_brack(10, 11) + ]) + ] + }; + } + + #[test] + fn peek_slice_start_end() { + parses_to! { + parser: PestParser, + input: "PEEK[-5..10]", + rule: Rule::peek_slice, + tokens: [ + peek_slice(0, 12, [ + opening_brack(4, 5), + integer(5, 7), + range_operator(7, 9), + integer(9, 11), + closing_brack(11, 12) + ]) + ] + }; + } + + #[test] + fn identifier() { + parses_to! { + parser: PestParser, + input: "_a8943", + rule: Rule::identifier, + tokens: [ + identifier(0, 6) + ] + }; + } + + #[test] + fn string() { + parses_to! { + parser: PestParser, + input: "\"aaaaa\\n\\r\\t\\\\\\0\\'\\\"\\x0F\\u{123abC}\\u{12}aaaaa\"", + rule: Rule::string, + tokens: [ + string(0, 46, [ + quote(0, 1), + inner_str(1, 45), + quote(45, 46) + ]) + ] + }; + } + + #[test] + fn insensitive_string() { + parses_to! { + parser: PestParser, + input: "^ \"\\\"hi\"", + rule: Rule::insensitive_string, + tokens: [ + insensitive_string(0, 9, [ + string(3, 9, [ + quote(3, 4), + inner_str(4, 8), + quote(8, 9) + ]) + ]) + ] + }; + } + + #[test] + fn range() { + parses_to! { + parser: PestParser, + input: "'\\n' .. '\\x1a'", + rule: Rule::range, + tokens: [ + range(0, 14, [ + character(0, 4, [ + single_quote(0, 1), + inner_chr(1, 3), + single_quote(3, 4) + ]), + range_operator(5, 7), + character(8, 14, [ + single_quote(8, 9), + inner_chr(9, 13), + single_quote(13, 14) + ]) + ]) + ] + }; + } + + #[test] + fn character() { + parses_to! { + parser: PestParser, + input: "'\\u{123abC}'", + rule: Rule::character, + tokens: [ + character(0, 12, [ + single_quote(0, 1), + inner_chr(1, 11), + single_quote(11, 12) + ]) + ] + }; + } + + #[test] + fn number() { + parses_to! { + parser: PestParser, + input: "0123", + rule: Rule::number, + tokens: [ + number(0, 4) + ] + }; + } + + #[test] + fn comment() { + parses_to! { + parser: PestParser, + input: "a ~ // asda\n b", + rule: Rule::expression, + tokens: [ + expression(0, 17, [ + term(0, 2, [ + identifier(0, 1) + ]), + sequence_operator(2, 3), + term(16, 17, [ + identifier(16, 17) + ]) + ]) + ] + }; + } + + #[test] + fn wrong_identifier() { + fails_with! { + parser: PestParser, + input: "0", + rule: Rule::grammar_rules, + positives: vec![Rule::identifier], + negatives: vec![], + pos: 0 + }; + } + + #[test] + fn missing_assignment_operator() { + fails_with! { + parser: PestParser, + input: "a {}", + rule: Rule::grammar_rules, + positives: vec![Rule::assignment_operator], + negatives: vec![], + pos: 2 + }; + } + + #[test] + fn wrong_modifier() { + fails_with! { + parser: PestParser, + input: "a = *{}", + rule: Rule::grammar_rules, + positives: vec![ + Rule::opening_brace, + Rule::silent_modifier, + Rule::atomic_modifier, + Rule::compound_atomic_modifier, + Rule::non_atomic_modifier + ], + negatives: vec![], + pos: 4 + }; + } + + #[test] + fn missing_opening_brace() { + fails_with! { + parser: PestParser, + input: "a = _", + rule: Rule::grammar_rules, + positives: vec![Rule::opening_brace], + negatives: vec![], + pos: 5 + }; + } + + #[test] + fn empty_rule() { + fails_with! { + parser: PestParser, + input: "a = {}", + rule: Rule::grammar_rules, + positives: vec![Rule::term], + negatives: vec![], + pos: 5 + }; + } + + #[test] + fn missing_rhs() { + fails_with! { + parser: PestParser, + input: "a = { b ~ }", + rule: Rule::grammar_rules, + positives: vec![Rule::term], + negatives: vec![], + pos: 10 + }; + } + + #[test] + fn wrong_op() { + fails_with! { + parser: PestParser, + input: "a = { b % }", + rule: Rule::grammar_rules, + positives: vec![ + Rule::opening_brace, + Rule::closing_brace, + Rule::sequence_operator, + Rule::choice_operator, + Rule::optional_operator, + Rule::repeat_operator, + Rule::repeat_once_operator + ], + negatives: vec![], + pos: 8 + }; + } + + #[test] + fn missing_closing_paren() { + fails_with! { + parser: PestParser, + input: "a = { (b }", + rule: Rule::grammar_rules, + positives: vec![ + Rule::opening_brace, + Rule::closing_paren, + Rule::sequence_operator, + Rule::choice_operator, + Rule::optional_operator, + Rule::repeat_operator, + Rule::repeat_once_operator + ], + negatives: vec![], + pos: 9 + }; + } + + #[test] + fn missing_term() { + fails_with! { + parser: PestParser, + input: "a = { ! }", + rule: Rule::grammar_rules, + positives: vec![ + Rule::opening_paren, + Rule::positive_predicate_operator, + Rule::negative_predicate_operator, + Rule::_push, + Rule::peek_slice, + Rule::identifier, + Rule::insensitive_string, + Rule::quote, + Rule::single_quote + ], + negatives: vec![], + pos: 8 + }; + } + + #[test] + fn string_missing_ending_quote() { + fails_with! { + parser: PestParser, + input: "a = { \" }", + rule: Rule::grammar_rules, + positives: vec![Rule::quote], + negatives: vec![], + pos: 9 + }; + } + + #[test] + fn insensitive_missing_string() { + fails_with! { + parser: PestParser, + input: "a = { ^ }", + rule: Rule::grammar_rules, + positives: vec![Rule::quote], + negatives: vec![], + pos: 8 + }; + } + + #[test] + fn char_missing_ending_single_quote() { + fails_with! { + parser: PestParser, + input: "a = { \' }", + rule: Rule::grammar_rules, + positives: vec![Rule::single_quote], + negatives: vec![], + pos: 8 + }; + } + + #[test] + fn range_missing_range_operator() { + fails_with! { + parser: PestParser, + input: "a = { \'a\' }", + rule: Rule::grammar_rules, + positives: vec![Rule::range_operator], + negatives: vec![], + pos: 10 + }; + } + + #[test] + fn wrong_postfix() { + fails_with! { + parser: PestParser, + input: "a = { a& }", + rule: Rule::grammar_rules, + positives: vec![ + Rule::opening_brace, + Rule::closing_brace, + Rule::sequence_operator, + Rule::choice_operator, + Rule::optional_operator, + Rule::repeat_operator, + Rule::repeat_once_operator + ], + negatives: vec![], + pos: 7 + }; + } + + #[test] + fn ast() { + let input = + "rule = _{ a{1} ~ \"a\"{3,} ~ b{, 2} ~ \"b\"{1, 2} | !(^\"c\" | PUSH('d'..'e'))?* }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + let ast = consume_rules_with_spans(pairs).unwrap(); + let ast: Vec<_> = ast.into_iter().map(|rule| convert_rule(rule)).collect(); + + assert_eq!( + ast, + vec![AstRule { + name: "rule".to_owned(), + ty: RuleType::Silent, + expr: Expr::Choice( + Box::new(Expr::Seq( + Box::new(Expr::Seq( + Box::new(Expr::Seq( + Box::new(Expr::RepExact(Box::new(Expr::Ident("a".to_owned())), 1)), + Box::new(Expr::RepMin(Box::new(Expr::Str("a".to_owned())), 3)) + )), + Box::new(Expr::RepMax(Box::new(Expr::Ident("b".to_owned())), 2)) + )), + Box::new(Expr::RepMinMax(Box::new(Expr::Str("b".to_owned())), 1, 2)) + )), + Box::new(Expr::NegPred(Box::new(Expr::Rep(Box::new(Expr::Opt( + Box::new(Expr::Choice( + Box::new(Expr::Insens("c".to_owned())), + Box::new(Expr::Push(Box::new(Expr::Range( + "d".to_owned(), + "e".to_owned() + )))) + )) + )))))) + ) + },] + ); + } + + #[test] + fn ast_peek_slice() { + let input = "rule = _{ PEEK[-04..] ~ PEEK[..3] }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + let ast = consume_rules_with_spans(pairs).unwrap(); + let ast: Vec<_> = ast.into_iter().map(|rule| convert_rule(rule)).collect(); + + assert_eq!( + ast, + vec![AstRule { + name: "rule".to_owned(), + ty: RuleType::Silent, + expr: Expr::Seq( + Box::new(Expr::PeekSlice(-4, None)), + Box::new(Expr::PeekSlice(0, Some(3))), + ) + }], + ); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | rule = { \"\"{4294967297} } + | ^--------^ + | + = number cannot overflow u32")] + fn repeat_exact_overflow() { + let input = "rule = { \"\"{4294967297} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | rule = { \"\"{0} } + | ^ + | + = cannot repeat 0 times")] + fn repeat_exact_zero() { + let input = "rule = { \"\"{0} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | rule = { \"\"{4294967297,} } + | ^--------^ + | + = number cannot overflow u32")] + fn repeat_min_overflow() { + let input = "rule = { \"\"{4294967297,} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:14 + | +1 | rule = { \"\"{,4294967297} } + | ^--------^ + | + = number cannot overflow u32")] + fn repeat_max_overflow() { + let input = "rule = { \"\"{,4294967297} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:14 + | +1 | rule = { \"\"{,0} } + | ^ + | + = cannot repeat 0 times")] + fn repeat_max_zero() { + let input = "rule = { \"\"{,0} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | rule = { \"\"{4294967297,4294967298} } + | ^--------^ + | + = number cannot overflow u32")] + fn repeat_min_max_overflow() { + let input = "rule = { \"\"{4294967297,4294967298} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:15 + | +1 | rule = { \"\"{0,0} } + | ^ + | + = cannot repeat 0 times")] + fn repeat_min_max_zero() { + let input = "rule = { \"\"{0,0} }"; + + let pairs = PestParser::parse(Rule::grammar_rules, input).unwrap(); + unwrap_or_report(consume_rules_with_spans(pairs)); + } + + #[test] + fn unescape_all() { + let string = r"a\nb\x55c\u{111}d"; + + assert_eq!(unescape(string), Some("a\nb\x55c\u{111}d".to_owned())); + } + + #[test] + fn unescape_empty_escape() { + let string = r"\"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_wrong_escape() { + let string = r"\w"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_backslash() { + let string = "\\\\"; + assert_eq!(unescape(string), Some("\\".to_owned())); + } + + #[test] + fn unescape_return() { + let string = "\\r"; + assert_eq!(unescape(string), Some("\r".to_owned())); + } + + #[test] + fn unescape_tab() { + let string = "\\t"; + assert_eq!(unescape(string), Some("\t".to_owned())); + } + + #[test] + fn unescape_null() { + let string = "\\0"; + assert_eq!(unescape(string), Some("\0".to_owned())); + } + + #[test] + fn unescape_single_quote() { + let string = "\\'"; + assert_eq!(unescape(string), Some("\'".to_owned())); + } + + #[test] + fn unescape_wrong_byte() { + let string = r"\xfg"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_short_byte() { + let string = r"\xf"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_no_open_brace_unicode() { + let string = r"\u11"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_no_close_brace_unicode() { + let string = r"\u{11"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_short_unicode() { + let string = r"\u{1}"; + + assert_eq!(unescape(string), None); + } + + #[test] + fn unescape_long_unicode() { + let string = r"\u{1111111}"; + + assert_eq!(unescape(string), None); + } +} diff --git a/vendor/pest_meta/src/validator.rs b/vendor/pest_meta/src/validator.rs new file mode 100644 index 000000000..a358dbeec --- /dev/null +++ b/vendor/pest_meta/src/validator.rs @@ -0,0 +1,851 @@ +// pest. The Elegant Parser +// Copyright (c) 2018 Dragoș Tiselice +// +// Licensed under the Apache License, Version 2.0 +// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT +// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. All files in the project carrying such notice may not be copied, +// modified, or distributed except according to those terms. + +use std::collections::{HashMap, HashSet}; + +use pest::error::{Error, ErrorVariant, InputLocation}; +use pest::iterators::Pairs; +use pest::Span; + +use parser::{ParserExpr, ParserNode, ParserRule, Rule}; +use UNICODE_PROPERTY_NAMES; + +#[allow(clippy::needless_pass_by_value)] +pub fn validate_pairs<'i>(pairs: Pairs<'i, Rule>) -> Result<Vec<&'i str>, Vec<Error<Rule>>> { + let mut rust_keywords = HashSet::new(); + rust_keywords.insert("abstract"); + rust_keywords.insert("alignof"); + rust_keywords.insert("as"); + rust_keywords.insert("become"); + rust_keywords.insert("box"); + rust_keywords.insert("break"); + rust_keywords.insert("const"); + rust_keywords.insert("continue"); + rust_keywords.insert("crate"); + rust_keywords.insert("do"); + rust_keywords.insert("else"); + rust_keywords.insert("enum"); + rust_keywords.insert("extern"); + rust_keywords.insert("false"); + rust_keywords.insert("final"); + rust_keywords.insert("fn"); + rust_keywords.insert("for"); + rust_keywords.insert("if"); + rust_keywords.insert("impl"); + rust_keywords.insert("in"); + rust_keywords.insert("let"); + rust_keywords.insert("loop"); + rust_keywords.insert("macro"); + rust_keywords.insert("match"); + rust_keywords.insert("mod"); + rust_keywords.insert("move"); + rust_keywords.insert("mut"); + rust_keywords.insert("offsetof"); + rust_keywords.insert("override"); + rust_keywords.insert("priv"); + rust_keywords.insert("proc"); + rust_keywords.insert("pure"); + rust_keywords.insert("pub"); + rust_keywords.insert("ref"); + rust_keywords.insert("return"); + rust_keywords.insert("Self"); + rust_keywords.insert("self"); + rust_keywords.insert("sizeof"); + rust_keywords.insert("static"); + rust_keywords.insert("struct"); + rust_keywords.insert("super"); + rust_keywords.insert("trait"); + rust_keywords.insert("true"); + rust_keywords.insert("type"); + rust_keywords.insert("typeof"); + rust_keywords.insert("unsafe"); + rust_keywords.insert("unsized"); + rust_keywords.insert("use"); + rust_keywords.insert("virtual"); + rust_keywords.insert("where"); + rust_keywords.insert("while"); + rust_keywords.insert("yield"); + + let mut pest_keywords = HashSet::new(); + pest_keywords.insert("_"); + pest_keywords.insert("ANY"); + pest_keywords.insert("DROP"); + pest_keywords.insert("EOI"); + pest_keywords.insert("PEEK"); + pest_keywords.insert("PEEK_ALL"); + pest_keywords.insert("POP"); + pest_keywords.insert("POP_ALL"); + pest_keywords.insert("PUSH"); + pest_keywords.insert("SOI"); + + let mut builtins = HashSet::new(); + builtins.insert("ANY"); + builtins.insert("DROP"); + builtins.insert("EOI"); + builtins.insert("PEEK"); + builtins.insert("PEEK_ALL"); + builtins.insert("POP"); + builtins.insert("POP_ALL"); + builtins.insert("SOI"); + builtins.insert("ASCII_DIGIT"); + builtins.insert("ASCII_NONZERO_DIGIT"); + builtins.insert("ASCII_BIN_DIGIT"); + builtins.insert("ASCII_OCT_DIGIT"); + builtins.insert("ASCII_HEX_DIGIT"); + builtins.insert("ASCII_ALPHA_LOWER"); + builtins.insert("ASCII_ALPHA_UPPER"); + builtins.insert("ASCII_ALPHA"); + builtins.insert("ASCII_ALPHANUMERIC"); + builtins.insert("ASCII"); + builtins.insert("NEWLINE"); + builtins.extend(UNICODE_PROPERTY_NAMES); + + let definitions: Vec<_> = pairs + .clone() + .filter(|pair| pair.as_rule() == Rule::grammar_rule) + .map(|pair| pair.into_inner().next().unwrap().as_span()) + .collect(); + let called_rules: Vec<_> = pairs + .clone() + .filter(|pair| pair.as_rule() == Rule::grammar_rule) + .flat_map(|pair| { + pair.into_inner() + .flatten() + .skip(1) + .filter(|pair| pair.as_rule() == Rule::identifier) + .map(|pair| pair.as_span()) + }) + .collect(); + + let mut errors = vec![]; + + errors.extend(validate_rust_keywords(&definitions, &rust_keywords)); + errors.extend(validate_pest_keywords(&definitions, &pest_keywords)); + errors.extend(validate_already_defined(&definitions)); + errors.extend(validate_undefined(&definitions, &called_rules, &builtins)); + + if !errors.is_empty() { + return Err(errors); + } + + let definitions: HashSet<_> = definitions.iter().map(|span| span.as_str()).collect(); + let called_rules: HashSet<_> = called_rules.iter().map(|span| span.as_str()).collect(); + + let defaults = called_rules.difference(&definitions); + + Ok(defaults.cloned().collect()) +} + +#[allow(clippy::implicit_hasher, clippy::ptr_arg)] +pub fn validate_rust_keywords<'i>( + definitions: &Vec<Span<'i>>, + rust_keywords: &HashSet<&str>, +) -> Vec<Error<Rule>> { + let mut errors = vec![]; + + for definition in definitions { + let name = definition.as_str(); + + if rust_keywords.contains(name) { + errors.push(Error::new_from_span( + ErrorVariant::CustomError { + message: format!("{} is a rust keyword", name), + }, + definition.clone(), + )) + } + } + + errors +} + +#[allow(clippy::implicit_hasher, clippy::ptr_arg)] +pub fn validate_pest_keywords<'i>( + definitions: &Vec<Span<'i>>, + pest_keywords: &HashSet<&str>, +) -> Vec<Error<Rule>> { + let mut errors = vec![]; + + for definition in definitions { + let name = definition.as_str(); + + if pest_keywords.contains(name) { + errors.push(Error::new_from_span( + ErrorVariant::CustomError { + message: format!("{} is a pest keyword", name), + }, + definition.clone(), + )) + } + } + + errors +} + +#[allow(clippy::ptr_arg)] +pub fn validate_already_defined<'i>(definitions: &Vec<Span<'i>>) -> Vec<Error<Rule>> { + let mut errors = vec![]; + let mut defined = HashSet::new(); + + for definition in definitions { + let name = definition.as_str(); + + if defined.contains(&name) { + errors.push(Error::new_from_span( + ErrorVariant::CustomError { + message: format!("rule {} already defined", name), + }, + definition.clone(), + )) + } else { + defined.insert(name); + } + } + + errors +} + +#[allow(clippy::implicit_hasher, clippy::ptr_arg)] +pub fn validate_undefined<'i>( + definitions: &Vec<Span<'i>>, + called_rules: &Vec<Span<'i>>, + builtins: &HashSet<&str>, +) -> Vec<Error<Rule>> { + let mut errors = vec![]; + let definitions: HashSet<_> = definitions.iter().map(|span| span.as_str()).collect(); + + for rule in called_rules { + let name = rule.as_str(); + + if !definitions.contains(name) && !builtins.contains(name) { + errors.push(Error::new_from_span( + ErrorVariant::CustomError { + message: format!("rule {} is undefined", name), + }, + rule.clone(), + )) + } + } + + errors +} + +#[allow(clippy::ptr_arg)] +pub fn validate_ast<'a, 'i: 'a>(rules: &'a Vec<ParserRule<'i>>) -> Vec<Error<Rule>> { + let mut errors = vec![]; + + errors.extend(validate_repetition(rules)); + errors.extend(validate_choices(rules)); + errors.extend(validate_whitespace_comment(rules)); + errors.extend(validate_left_recursion(rules)); + + errors.sort_by_key(|error| match error.location { + InputLocation::Span(span) => span, + _ => unreachable!(), + }); + + errors +} + +fn is_non_progressing<'i>( + expr: &ParserExpr<'i>, + rules: &HashMap<String, &ParserNode<'i>>, + trace: &mut Vec<String>, +) -> bool { + match *expr { + ParserExpr::Str(ref string) => string == "", + ParserExpr::Ident(ref ident) => { + if ident == "soi" || ident == "eoi" { + return true; + } + + if !trace.contains(ident) { + if let Some(node) = rules.get(ident) { + trace.push(ident.clone()); + let result = is_non_progressing(&node.expr, rules, trace); + trace.pop().unwrap(); + + return result; + } + } + + false + } + ParserExpr::PosPred(_) => true, + ParserExpr::NegPred(_) => true, + ParserExpr::Seq(ref lhs, ref rhs) => { + is_non_progressing(&lhs.expr, rules, trace) + && is_non_progressing(&rhs.expr, rules, trace) + } + ParserExpr::Choice(ref lhs, ref rhs) => { + is_non_progressing(&lhs.expr, rules, trace) + || is_non_progressing(&rhs.expr, rules, trace) + } + _ => false, + } +} + +fn is_non_failing<'i>( + expr: &ParserExpr<'i>, + rules: &HashMap<String, &ParserNode<'i>>, + trace: &mut Vec<String>, +) -> bool { + match *expr { + ParserExpr::Str(ref string) => string == "", + ParserExpr::Ident(ref ident) => { + if !trace.contains(ident) { + if let Some(node) = rules.get(ident) { + trace.push(ident.clone()); + let result = is_non_failing(&node.expr, rules, trace); + trace.pop().unwrap(); + + return result; + } + } + + false + } + ParserExpr::Opt(_) => true, + ParserExpr::Rep(_) => true, + ParserExpr::Seq(ref lhs, ref rhs) => { + is_non_failing(&lhs.expr, rules, trace) && is_non_failing(&rhs.expr, rules, trace) + } + ParserExpr::Choice(ref lhs, ref rhs) => { + is_non_failing(&lhs.expr, rules, trace) || is_non_failing(&rhs.expr, rules, trace) + } + _ => false, + } +} + +fn validate_repetition<'a, 'i: 'a>(rules: &'a [ParserRule<'i>]) -> Vec<Error<Rule>> { + let mut result = vec![]; + let map = to_hash_map(rules); + + for rule in rules { + let mut errors = rule.node + .clone() + .filter_map_top_down(|node| match node.expr { + ParserExpr::Rep(ref other) + | ParserExpr::RepOnce(ref other) + | ParserExpr::RepMin(ref other, _) => { + if is_non_failing(&other.expr, &map, &mut vec![]) { + Some(Error::new_from_span( + ErrorVariant::CustomError { + message: + "expression inside repetition cannot fail and will repeat \ + infinitely" + .to_owned() + }, + node.span.clone() + )) + } else if is_non_progressing(&other.expr, &map, &mut vec![]) { + Some(Error::new_from_span( + ErrorVariant::CustomError { + message: + "expression inside repetition is non-progressing and will repeat \ + infinitely" + .to_owned(), + }, + node.span.clone() + )) + } else { + None + } + } + _ => None + }); + + result.append(&mut errors); + } + + result +} + +fn validate_choices<'a, 'i: 'a>(rules: &'a [ParserRule<'i>]) -> Vec<Error<Rule>> { + let mut result = vec![]; + let map = to_hash_map(rules); + + for rule in rules { + let mut errors = rule + .node + .clone() + .filter_map_top_down(|node| match node.expr { + ParserExpr::Choice(ref lhs, _) => { + let node = match lhs.expr { + ParserExpr::Choice(_, ref rhs) => rhs, + _ => lhs, + }; + + if is_non_failing(&node.expr, &map, &mut vec![]) { + Some(Error::new_from_span( + ErrorVariant::CustomError { + message: + "expression cannot fail; following choices cannot be reached" + .to_owned(), + }, + node.span.clone(), + )) + } else { + None + } + } + _ => None, + }); + + result.append(&mut errors); + } + + result +} + +fn validate_whitespace_comment<'a, 'i: 'a>(rules: &'a [ParserRule<'i>]) -> Vec<Error<Rule>> { + let map = to_hash_map(rules); + + rules + .iter() + .filter_map(|rule| { + if rule.name == "WHITESPACE" || rule.name == "COMMENT" { + if is_non_failing(&rule.node.expr, &map, &mut vec![]) { + Some(Error::new_from_span( + ErrorVariant::CustomError { + message: format!( + "{} cannot fail and will repeat infinitely", + &rule.name + ), + }, + rule.node.span.clone(), + )) + } else if is_non_progressing(&rule.node.expr, &map, &mut vec![]) { + Some(Error::new_from_span( + ErrorVariant::CustomError { + message: format!( + "{} is non-progressing and will repeat infinitely", + &rule.name + ), + }, + rule.node.span.clone(), + )) + } else { + None + } + } else { + None + } + }) + .collect() +} + +fn validate_left_recursion<'a, 'i: 'a>(rules: &'a [ParserRule<'i>]) -> Vec<Error<Rule>> { + left_recursion(to_hash_map(rules)) +} + +fn to_hash_map<'a, 'i: 'a>(rules: &'a [ParserRule<'i>]) -> HashMap<String, &'a ParserNode<'i>> { + rules.iter().map(|r| (r.name.clone(), &r.node)).collect() +} + +#[allow(clippy::needless_pass_by_value)] +fn left_recursion<'a, 'i: 'a>(rules: HashMap<String, &'a ParserNode<'i>>) -> Vec<Error<Rule>> { + fn check_expr<'a, 'i: 'a>( + node: &'a ParserNode<'i>, + rules: &'a HashMap<String, &ParserNode<'i>>, + trace: &mut Vec<String>, + ) -> Option<Error<Rule>> { + match node.expr.clone() { + ParserExpr::Ident(other) => { + if trace[0] == other { + trace.push(other); + let chain = trace + .iter() + .map(|ident| ident.as_ref()) + .collect::<Vec<_>>() + .join(" -> "); + + return Some(Error::new_from_span( + ErrorVariant::CustomError { + message: format!( + "rule {} is left-recursive ({}); pest::prec_climber might be useful \ + in this case", + node.span.as_str(), + chain + ) + }, + node.span.clone() + )); + } + + if !trace.contains(&other) { + if let Some(node) = rules.get(&other) { + trace.push(other); + let result = check_expr(node, rules, trace); + trace.pop().unwrap(); + + return result; + } + } + + None + } + ParserExpr::Seq(ref lhs, ref rhs) => { + if is_non_failing(&lhs.expr, rules, &mut vec![trace.last().unwrap().clone()]) { + check_expr(rhs, rules, trace) + } else { + check_expr(lhs, rules, trace) + } + } + ParserExpr::Choice(ref lhs, ref rhs) => { + check_expr(&lhs, rules, trace).or_else(|| check_expr(&rhs, rules, trace)) + } + ParserExpr::Rep(ref node) => check_expr(&node, rules, trace), + ParserExpr::RepOnce(ref node) => check_expr(&node, rules, trace), + ParserExpr::Opt(ref node) => check_expr(&node, rules, trace), + ParserExpr::PosPred(ref node) => check_expr(&node, rules, trace), + ParserExpr::NegPred(ref node) => check_expr(&node, rules, trace), + ParserExpr::Push(ref node) => check_expr(&node, rules, trace), + _ => None, + } + } + + let mut errors = vec![]; + + for (ref name, ref node) in &rules { + let name = (*name).clone(); + + if let Some(error) = check_expr(node, &rules, &mut vec![name]) { + errors.push(error); + } + } + + errors +} + +#[cfg(test)] +mod tests { + use super::super::parser::{consume_rules, PestParser}; + use super::super::unwrap_or_report; + use super::*; + use pest::Parser; + + #[test] + #[should_panic(expected = "grammar error + + --> 1:1 + | +1 | let = { \"a\" } + | ^-^ + | + = let is a rust keyword")] + fn rust_keyword() { + let input = "let = { \"a\" }"; + unwrap_or_report(validate_pairs( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:1 + | +1 | ANY = { \"a\" } + | ^-^ + | + = ANY is a pest keyword")] + fn pest_keyword() { + let input = "ANY = { \"a\" }"; + unwrap_or_report(validate_pairs( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | a = { \"a\" } a = { \"a\" } + | ^ + | + = rule a already defined")] + fn already_defined() { + let input = "a = { \"a\" } a = { \"a\" }"; + unwrap_or_report(validate_pairs( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { b } + | ^ + | + = rule b is undefined")] + fn undefined() { + let input = "a = { b }"; + unwrap_or_report(validate_pairs( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + fn valid_recursion() { + let input = "a = { \"\" ~ \"a\"? ~ \"a\"* ~ (\"a\" | \"b\") ~ a }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:16 + | +1 | WHITESPACE = { \"\" } + | ^^ + | + = WHITESPACE cannot fail and will repeat infinitely")] + fn non_failing_whitespace() { + let input = "WHITESPACE = { \"\" }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | COMMENT = { soi } + | ^-^ + | + = COMMENT is non-progressing and will repeat infinitely")] + fn non_progressing_comment() { + let input = "COMMENT = { soi }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { (\"\")* } + | ^---^ + | + = expression inside repetition cannot fail and will repeat infinitely")] + fn non_failing_repetition() { + let input = "a = { (\"\")* }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:18 + | +1 | a = { \"\" } b = { a* } + | ^^ + | + = expression inside repetition cannot fail and will repeat infinitely")] + fn indirect_non_failing_repetition() { + let input = "a = { \"\" } b = { a* }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:20 + | +1 | a = { \"a\" ~ (\"b\" ~ (\"\")*) } + | ^---^ + | + = expression inside repetition cannot fail and will repeat infinitely")] + fn deep_non_failing_repetition() { + let input = "a = { \"a\" ~ (\"b\" ~ (\"\")*) }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { (\"\" ~ &\"a\" ~ !\"a\" ~ (soi | eoi))* } + | ^-------------------------------^ + | + = expression inside repetition is non-progressing and will repeat infinitely")] + fn non_progressing_repetition() { + let input = "a = { (\"\" ~ &\"a\" ~ !\"a\" ~ (soi | eoi))* }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:20 + | +1 | a = { !\"a\" } b = { a* } + | ^^ + | + = expression inside repetition is non-progressing and will repeat infinitely")] + fn indirect_non_progressing_repetition() { + let input = "a = { !\"a\" } b = { a* }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { a } + | ^ + | + = rule a is left-recursive (a -> a); pest::prec_climber might be useful in this case")] + fn simple_left_recursion() { + let input = "a = { a }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { b } b = { a } + | ^ + | + = rule b is left-recursive (b -> a -> b); pest::prec_climber might be useful in this case + + --> 1:17 + | +1 | a = { b } b = { a } + | ^ + | + = rule a is left-recursive (a -> b -> a); pest::prec_climber might be useful in this case")] + fn indirect_left_recursion() { + let input = "a = { b } b = { a }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:39 + | +1 | a = { \"\" ~ \"a\"? ~ \"a\"* ~ (\"a\" | \"\") ~ a } + | ^ + | + = rule a is left-recursive (a -> a); pest::prec_climber might be useful in this case")] + fn non_failing_left_recursion() { + let input = "a = { \"\" ~ \"a\"? ~ \"a\"* ~ (\"a\" | \"\") ~ a }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | a = { \"a\" | a } + | ^ + | + = rule a is left-recursive (a -> a); pest::prec_climber might be useful in this case")] + fn non_primary_choice_left_recursion() { + let input = "a = { \"a\" | a }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { \"a\"* | \"a\" | \"b\" } + | ^--^ + | + = expression cannot fail; following choices cannot be reached")] + fn lhs_non_failing_choice() { + let input = "a = { \"a\"* | \"a\" | \"b\" }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:13 + | +1 | a = { \"a\" | \"a\"* | \"b\" } + | ^--^ + | + = expression cannot fail; following choices cannot be reached")] + fn lhs_non_failing_choice_middle() { + let input = "a = { \"a\" | \"a\"* | \"b\" }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + #[should_panic(expected = "grammar error + + --> 1:7 + | +1 | a = { b | \"a\" } b = { \"b\"* | \"c\" } + | ^ + | + = expression cannot fail; following choices cannot be reached + + --> 1:23 + | +1 | a = { b | \"a\" } b = { \"b\"* | \"c\" } + | ^--^ + | + = expression cannot fail; following choices cannot be reached")] + fn lhs_non_failing_nested_choices() { + let input = "a = { b | \"a\" } b = { \"b\"* | \"c\" }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } + + #[test] + fn skip_can_be_defined() { + let input = "skip = { \"\" }"; + unwrap_or_report(consume_rules( + PestParser::parse(Rule::grammar_rules, input).unwrap(), + )); + } +} |