From 29040d429d321ed6489bc3a0d364a9ae59221806 Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Sun, 13 Sep 2026 14:45:33 +0000 Subject: [PATCH] =?UTF-8?q?deps/vm:=20vendor=20regress=200.11.1=20?= =?UTF-8?q?=E8=A1=A5=20Script/Script=5FExtensions=20=E7=9A=84=20Unknown(Zz?= =?UTF-8?q?zz)=20=E5=8F=96=E5=80=BC=E2=80=94=E2=80=94=E4=B8=8A=E6=B8=B8?= =?UTF-8?q?=E8=A1=A8=E7=BC=BA=E6=9C=AA=E5=88=86=E9=85=8D=E7=A0=81=E7=82=B9?= =?UTF-8?q?=E9=9B=86=E5=8F=96=E5=80=BC=EF=BC=8C=E8=A7=84=E8=8C=83=E5=90=88?= =?UTF-8?q?=E6=B3=95=E6=A8=A1=E5=BC=8F=20\p{Script=3DUnknown}=20=E7=BC=96?= =?UTF-8?q?=E8=AF=91=E6=9C=9F=20SyntaxError=EF=BC=9Bfork=20=E7=BA=AF?= =?UTF-8?q?=E5=A2=9E=E9=87=8F=EF=BC=880=20=E8=A1=8C=E6=94=B9=E5=8A=A8?= =?UTF-8?q?=E4=B8=8A=E6=B8=B8=E8=A1=8C=EF=BC=8C=E4=BB=85=E8=A1=A5=E5=8C=BA?= =?UTF-8?q?=E9=97=B4=E8=A1=A8=E4=B8=8E=E8=A7=A3=E6=9E=90=E8=87=82=EF=BC=89?= =?UTF-8?q?=EF=BC=8C=E5=9B=9E=E5=BD=92=E9=92=89=E5=9B=9B=E5=88=99=EF=BC=88?= =?UTF-8?q?=E6=9C=AA=E5=88=86=E9=85=8D=E5=8C=B9=E9=85=8D/=E5=B7=B2?= =?UTF-8?q?=E5=88=86=E9=85=8D=E4=B8=8D=E5=8C=B9=E9=85=8D/sc=C2=B7scx=C2=B7?= =?UTF-8?q?Zzzz=20=E5=88=AB=E5=90=8D/=E6=97=A2=E6=9C=89=E5=8F=96=E5=80=BC?= =?UTF-8?q?=E4=B8=8D=E6=89=B0=E5=8A=A8=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.lock | 2 - Cargo.toml | 6 + .../oxide_vm/tests/builtins_regexp_tests.rs | 44 + third_party/regress/.cargo-ok | 1 + third_party/regress/.cargo_vcs_info.json | 7 + third_party/regress/.github/dependabot.yml | 11 + .../regress/.github/workflows/autofix.yml | 31 + .../regress/.github/workflows/rust.yml | 77 + third_party/regress/.gitignore | 20 + third_party/regress/Cargo.toml | 34 + third_party/regress/LICENSE-APACHE | 201 + third_party/regress/LICENSE-MIT | 21 + third_party/regress/README.md | 71 + third_party/regress/src/api.rs | 986 + third_party/regress/src/bytesearch.rs | 389 + third_party/regress/src/charclasses.rs | 81 + third_party/regress/src/classicalbacktrack.rs | 1172 + third_party/regress/src/codepointset.rs | 498 + third_party/regress/src/cursor.rs | 77 + third_party/regress/src/emit.rs | 410 + third_party/regress/src/exec.rs | 56 + third_party/regress/src/indexing.rs | 1292 + third_party/regress/src/insn.rs | 220 + third_party/regress/src/ir.rs | 590 + third_party/regress/src/lib.rs | 187 + third_party/regress/src/matchers.rs | 113 + third_party/regress/src/optimizer.rs | 544 + third_party/regress/src/parse.rs | 2078 + third_party/regress/src/pikevm.rs | 501 + third_party/regress/src/position.rs | 185 + third_party/regress/src/scm.rs | 158 + third_party/regress/src/startpredicate.rs | 223 + third_party/regress/src/types.rs | 98 + third_party/regress/src/unicode.rs | 581 + third_party/regress/src/unicodetables.rs | 33975 ++++++++++++++++ third_party/regress/src/util.rs | 286 + 36 files changed, 45224 insertions(+), 2 deletions(-) create mode 100644 third_party/regress/.cargo-ok create mode 100644 third_party/regress/.cargo_vcs_info.json create mode 100644 third_party/regress/.github/dependabot.yml create mode 100644 third_party/regress/.github/workflows/autofix.yml create mode 100644 third_party/regress/.github/workflows/rust.yml create mode 100644 third_party/regress/.gitignore create mode 100644 third_party/regress/Cargo.toml create mode 100644 third_party/regress/LICENSE-APACHE create mode 100644 third_party/regress/LICENSE-MIT create mode 100644 third_party/regress/README.md create mode 100644 third_party/regress/src/api.rs create mode 100644 third_party/regress/src/bytesearch.rs create mode 100644 third_party/regress/src/charclasses.rs create mode 100644 third_party/regress/src/classicalbacktrack.rs create mode 100644 third_party/regress/src/codepointset.rs create mode 100644 third_party/regress/src/cursor.rs create mode 100644 third_party/regress/src/emit.rs create mode 100644 third_party/regress/src/exec.rs create mode 100644 third_party/regress/src/indexing.rs create mode 100644 third_party/regress/src/insn.rs create mode 100644 third_party/regress/src/ir.rs create mode 100644 third_party/regress/src/lib.rs create mode 100644 third_party/regress/src/matchers.rs create mode 100644 third_party/regress/src/optimizer.rs create mode 100644 third_party/regress/src/parse.rs create mode 100644 third_party/regress/src/pikevm.rs create mode 100644 third_party/regress/src/position.rs create mode 100644 third_party/regress/src/scm.rs create mode 100644 third_party/regress/src/startpredicate.rs create mode 100644 third_party/regress/src/types.rs create mode 100644 third_party/regress/src/unicode.rs create mode 100644 third_party/regress/src/unicodetables.rs create mode 100644 third_party/regress/src/util.rs diff --git a/Cargo.lock b/Cargo.lock index ffb4d511..3372a3ea 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1644,8 +1644,6 @@ checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "regress" version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "158a764437582235e3501f683b93a0a6f8d825d04a789dbe5ed30b8799b8908a" dependencies = [ "hashbrown 0.16.1", "memchr", diff --git a/Cargo.toml b/Cargo.toml index 6b3391a0..68dfd622 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -70,3 +70,9 @@ opt-level = 3 lto = true codegen-units = 1 panic = "abort" + +# 上游 0.11.1 的 Unicode 表缺 Script/Script_Extensions 的 Unknown（Zzzz，未分配 +# 码点集）取值，规范合法模式 \p{Script=Unknown} 无法编译。vendor 补丁在 0.11.1 +# 上补齐该取值，其余行为与上游 0.11.1 逐位一致。 +[patch.crates-io] +regress = { path = "third_party/regress" } diff --git a/crates/oxide_vm/tests/builtins_regexp_tests.rs b/crates/oxide_vm/tests/builtins_regexp_tests.rs index 7e9f7236..9f57be8b 100644 --- a/crates/oxide_vm/tests/builtins_regexp_tests.rs +++ b/crates/oxide_vm/tests/builtins_regexp_tests.rs @@ -249,3 +249,47 @@ fn regexp_to_string() { let result = eval(&mut vm, "/abc/gi.toString()").unwrap(); assert_eq!(to_str(&vm, result), "/abc/gi"); } + +// --- Unicode property escapes：Script/Script_Extensions 的 Unknown（Zzzz）取值 --- +// vendor 的 Unicode 表须含 Unknown（未分配码点集），否则合法模式编译期 SyntaxError。 + +#[test] +fn regexp_unicode_property_script_unknown_matches_unassigned() { + let mut vm = Vm::new(); + // U+038B 未分配：Script 与 Script_Extensions 均为 Unknown + let result = eval(&mut vm, "/\\p{Script=Unknown}/u.test(String.fromCodePoint(0x038B))").unwrap(); + assert!(result.as_bool(), "未分配码点应匹配 Script=Unknown"); + let result = eval(&mut vm, "/\\p{Script_Extensions=Unknown}/u.test(String.fromCodePoint(0x038B))").unwrap(); + assert!(result.as_bool(), "未分配码点应匹配 Script_Extensions=Unknown"); +} + +#[test] +fn regexp_unicode_property_script_unknown_rejects_assigned() { + let mut vm = Vm::new(); + // 已分配拉丁字母不属于 Unknown + let result = eval(&mut vm, "/\\p{Script=Unknown}/u.test('d')").unwrap(); + assert!(!result.as_bool(), "已分配码点不应匹配 Script=Unknown"); + let result = eval(&mut vm, "/\\P{Script=Unknown}/u.test('d')").unwrap(); + assert!(result.as_bool(), "取反后已分配码点应匹配"); +} + +#[test] +fn regexp_unicode_property_script_unknown_aliases() { + let mut vm = Vm::new(); + // 单字母缩写与符号名须同义解析 + for pattern in [r"\p{sc=Unknown}", r"\p{scx=Unknown}", r"\p{Script=Zzzz}", r"\p{scx=Zzzz}"] { + let source = format!("/{pattern}/u.test(String.fromCodePoint(0x038B))"); + let result = eval(&mut vm, &source).unwrap(); + assert!(result.as_bool(), "别名 {pattern} 应匹配未分配码点"); + } +} + +#[test] +fn regexp_unicode_property_script_existing_values_unchanged() { + // 补齐 Unknown 不得扰动既有取值：Adlam 等已分配 Script 行为保持 + let mut vm = Vm::new(); + let result = eval(&mut vm, "/\\p{Script=Adlam}/u.test(String.fromCodePoint(0x1E900))").unwrap(); + assert!(result.as_bool(), "既有 Script 取值行为应保持不变"); + let result = eval(&mut vm, "/\\p{Script=Adlam}/u.test('d')").unwrap(); + assert!(!result.as_bool(), "既有 Script 取值行为应保持不变"); +} diff --git a/third_party/regress/.cargo-ok b/third_party/regress/.cargo-ok new file mode 100644 index 00000000..5f8b7958 --- /dev/null +++ b/third_party/regress/.cargo-ok @@ -0,0 +1 @@ +{"v":1} \ No newline at end of file diff --git a/third_party/regress/.cargo_vcs_info.json b/third_party/regress/.cargo_vcs_info.json new file mode 100644 index 00000000..09dffdfe --- /dev/null +++ b/third_party/regress/.cargo_vcs_info.json @@ -0,0 +1,7 @@ +{ + "git": { + "sha1": "7e64ad5e6807b5503e5cc97a79e0f129b23c556b", + "dirty": true + }, + "path_in_vcs": "" +} \ No newline at end of file diff --git a/third_party/regress/.github/dependabot.yml b/third_party/regress/.github/dependabot.yml new file mode 100644 index 00000000..8ab9c505 --- /dev/null +++ b/third_party/regress/.github/dependabot.yml @@ -0,0 +1,11 @@ +--- +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "daily" + - package-ecosystem: "cargo" + directory: "/" + schedule: + interval: "daily" diff --git a/third_party/regress/.github/workflows/autofix.yml b/third_party/regress/.github/workflows/autofix.yml new file mode 100644 index 00000000..b653cb3b --- /dev/null +++ b/third_party/regress/.github/workflows/autofix.yml @@ -0,0 +1,31 @@ +name: autofix.ci +on: + workflow_call: + pull_request: + push: + branches: [ "main" ] +permissions: + contents: read + +jobs: + autofix: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v5 + - uses: actions/cache@v5 + with: + path: | + ~/.cargo/bin/ + ~/.cargo/registry/index/ + ~/.cargo/registry/cache/ + ~/.cargo/git/db/ + target/ + key: autofix-${{ hashFiles('**/Cargo.lock') }} + + - run: rustup toolchain install ${{ env.rust_clippy }} --profile minimal --component rustfmt --component clippy + - run: rustup default ${{ env.rust_clippy }} + + - run: cargo clippy --fix --workspace + - run: cargo fmt --all + + - uses: autofix-ci/action@7a166d7532b277f34e16238930461bf77f9d7ed8 diff --git a/third_party/regress/.github/workflows/rust.yml b/third_party/regress/.github/workflows/rust.yml new file mode 100644 index 00000000..7b45c54e --- /dev/null +++ b/third_party/regress/.github/workflows/rust.yml @@ -0,0 +1,77 @@ +on: + pull_request: + branches: + - "**" + push: + branches: + - "**" + +name: Continuous integration + +jobs: + check: + name: Check + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + - run: cargo check --verbose + + test: + name: Test Suite + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + features: + - "" + - "index-positions" + - "prohibit-unsafe" + - "utf16" + - "index-positions,prohibit-unsafe" + - "index-positions,utf16" + - "prohibit-unsafe,utf16" + - "index-positions,prohibit-unsafe,utf16" + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + - run: cargo test --features "${{ matrix.features }}" --verbose + + clippy: + name: Clippy + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@stable + with: + components: clippy + - uses: Swatinem/rust-cache@v2 + - run: cargo clippy --all-targets --features "backend-pikevm,std,index-positions,prohibit-unsafe,utf16" -- -D warnings + + test-nightly: + name: Test (Nightly) + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@nightly + - uses: Swatinem/rust-cache@v2 + - run: cargo test --all-features --verbose + + doc: + name: Documentation + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + - run: cargo doc --verbose --document-private-items + env: + RUSTDOCFLAGS: -D warnings diff --git a/third_party/regress/.gitignore b/third_party/regress/.gitignore new file mode 100644 index 00000000..c23f3c0e --- /dev/null +++ b/third_party/regress/.gitignore @@ -0,0 +1,20 @@ +/target +**/*.rs.bk +Cargo.lock +.vscode +.vscode/* +.DS_Store +regexp-pcre.js + +.claude/ +CLAUDE.md + +# Unicode Database Files +DerivedCoreProperties.txt +DerivedBinaryProperties.txt +DerivedGeneralCategory.txt +DerivedNormalizationProps.txt +CaseFolding.txt +emoji-data.txt +PropList.txt +Scripts.txt diff --git a/third_party/regress/Cargo.toml b/third_party/regress/Cargo.toml new file mode 100644 index 00000000..780efa10 --- /dev/null +++ b/third_party/regress/Cargo.toml @@ -0,0 +1,34 @@ +[package] +name = "regress" +version = "0.11.1" +authors = ["ridiculousfish "] +description = "A regular expression engine targeting EcmaScript syntax" +license = "MIT OR Apache-2.0" +repository = "https://github.com/ridiculousfish/regress" +keywords = ["regex", "regexp"] +edition = "2024" +readme = "README.md" + +[features] +default = ["backend-pikevm", "std"] + +std = ["memchr/std"] + +# Enables the PikeVM backend. +backend-pikevm = [] + +# Prefers indexes to pointers for bytecode IP and string positions, for the paranoid. +index-positions = [] + +# Prohibits all uses of unsafe code, for the paranoid. +prohibit-unsafe = [] + +# Enables UTF-16 support. This disables some optimizations, so it should only be used when necessary. +utf16 = [] + +# Enables Pattern trait implementation for str::find, str::contains, etc. +pattern = [] + +[dependencies] +hashbrown = "0.16.0" +memchr = { version = "2.4.0", default-features = false } diff --git a/third_party/regress/LICENSE-APACHE b/third_party/regress/LICENSE-APACHE new file mode 100644 index 00000000..ba174b81 --- /dev/null +++ b/third_party/regress/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 2020 ridiculous_fish + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/third_party/regress/LICENSE-MIT b/third_party/regress/LICENSE-MIT new file mode 100644 index 00000000..c31d54c1 --- /dev/null +++ b/third_party/regress/LICENSE-MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 ridiculous_fish + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/third_party/regress/README.md b/third_party/regress/README.md new file mode 100644 index 00000000..331fb8cf --- /dev/null +++ b/third_party/regress/README.md @@ -0,0 +1,71 @@ +# regress - REGex in Rust with EcmaScript Syntax + +oh no why + +## Introduction + +regress is a backtracking regular expression engine implemented in Rust, which targets JavaScript regular expression syntax. See [the crate documentation](https://docs.rs/regress) for more. + +It's fast, Unicode-aware, has few dependencies, and has a big test suite. It makes fewer guarantees than the `regex` crate but it enables more syntactic features, such as backreferences and lookaround assertions. + +## Syntax + +regress targets the EcmaScript 2018 standard regexp syntax, including support for gnarly cases such as variable-width lookbehind assertions containing capture groups. Note that subsequent standard have mostly left regexp syntax untouched, with a few exceptions such as the 'v' flag, which is supported. + +### That darn 'u' flag + +You will be sad to learn that JavaScript does not use UTF-8. + +Originally JavaScript was designed for UCS-2, with 16-bit characters. Later UCS-2 was supplanted with UTF-16; however this was not automatic for regexps, but instead required opt-in for each regexp, with the 'u' flag. For example, the grinning face emoji U+1F600 is represented in a JavaScript string as a surrogate pair U+D83D and U+DE00. In a regexp without the 'u' flag, these surrogate pairs are matched as distinct characters: + + const s = "😀"; + const re = /./; + const m = s.match(re); + console.log(m); // returns \uD83D, high surrogate + +This behavior is almost never desired but is required by the ES spec. It's also super-awkward to express in Rust, which uses UTF-8 extensively. See below for how regress handles this. + +The 'u' flag doesn't just modify character sets; it _also_ affects other behaviors such as how case-insensitive matching works, and (most bizarrely) the behavior of backreferences like \2. For example, in non-Unicode mode, \2 is a backreference if there are at least two capture groups; otherwise it is an octal escape (!). + +regress mostly ignores the 'u' flag for character decoding - that's instead given by the call site (see below). regress attempts to implement the other behaviors faithfully. + +### Character sets + +tl;dr use UTF-8 (or ASCII) input and the 'u' flag, unless you are implementing a JavaScript engine and care about strict conformance. + +To support JavaScript pre-Unicode semantics, regress supports multiple input forms on the `Regex` object. These are: + +- **UTF-8**. The default (unsuffixed) form. Input is `&str`. This always decodes whole characters from the input string. +- **ASCII**. Use the `*_ascii` family of functions on `Regex` if you know your input is ASCII. Input is still `&str`. +- **UTF-16**. Use the `*_utf16` family of functions. Input is `&[u16]`. Characters are always decoded as UTF-16. +- **UCS-2**. OG JavaScript. Use `*_ucs2` functions. Input is `&[u16]`. Surrogate pairs are split freely. Only use if you want to implement strict JS semantics. + +Both the UTF-16 and UCS-2 forms require the Rust feature 'utf16' to be enabled. It is off by default. + +### Fun Tools + +The `regress-tool` binary can be used for some fun. + +You can see how things get compiled with the `dump-phases` cli flag: + + > cargo run 'x{3,4}' 'i' --dump-phases + +You can run a little benchmark too, for example: + + > cargo run --release -- 'abcd' --flags 'i' --bench ~/3200.txt + +## OxideJS fork note + +This directory is a vendored copy of upstream `regress 0.11.1` (source at +`https://github.com/ridiculousfish/regress`, crate files from the crates.io +registry, licenses preserved in `LICENSE-APACHE` / `LICENSE-MIT`), consumed via +the workspace root `[patch.crates-io]` instead of the registry copy. + +Single deviation from upstream: the Unicode script value table +(`src/unicodetables.rs`) gains the `Unknown` (`Zzzz`) value — script and +script-extensions interval sets covering the unassigned code points — plus its +name/alias arm in the script-value parser. Upstream 0.11.1 lacks the value, +which rejects spec-legal patterns such as `\p{Script=Unknown}`; upstream 0.12.0 +has it, but the 0.11.1 → 0.12.0 delta changes broader parser/matcher behavior +this project does not want to absorb. All other files are unmodified upstream +0.11.1. diff --git a/third_party/regress/src/api.rs b/third_party/regress/src/api.rs new file mode 100644 index 00000000..1e43cdf2 --- /dev/null +++ b/third_party/regress/src/api.rs @@ -0,0 +1,986 @@ +use crate::classicalbacktrack; +use crate::emit; +use crate::exec; +use crate::indexing; +use crate::insn::CompiledRegex; +use crate::optimizer; +use crate::parse; +use crate::types::MAX_CAPTURE_GROUPS; +use std::iter::FusedIterator; + +#[cfg(feature = "utf16")] +use crate::{ + classicalbacktrack::MatchAttempter, + indexing::{InputIndexer, Ucs2Input, Utf16Input}, +}; + +#[cfg(feature = "backend-pikevm")] +use crate::pikevm; +use crate::util::to_char_sat; + +use core::{fmt, str::FromStr}; +#[cfg(feature = "std")] +#[cfg(not(feature = "std"))] +use { + alloc::{string::String, vec::Vec}, + hashbrown::{HashMap, hash_map::Iter}, +}; + +pub use parse::Error; + +/// Flags used to control regex parsing. +/// The default flags are case-sensitive, not-multiline, and optimizing. +#[derive(Debug, Copy, Clone, Default)] +pub struct Flags { + /// If set, make the regex case-insensitive. + /// Equivalent to the 'i' flag in JavaScript. + pub icase: bool, + + /// If set, ^ and $ match at line separators, not just the input boundaries. + /// Equivalent to the 'm' flag in JavaScript. + pub multiline: bool, + + /// If set, . matches at line separators as well as any other character. + /// Equivalent to the 's' flag in JavaScript. + pub dot_all: bool, + + /// If set, disable regex IR passes. + pub no_opt: bool, + + /// If set, the regex is interpreted as a Unicode regex. + /// Equivalent to the 'u' flag in JavaScript. + pub unicode: bool, + + /// If set, the regex is interpreted as a UnicodeSets regex. + /// Equivalent to the 'v' flag in JavaScript. + pub unicode_sets: bool, +} + +impl Flags { + /// Construct a Flags from a Unicode codepoints iterator, using JavaScript field names. + /// 'i' means to ignore case, 'm' means multiline, 'u' means unicode. + /// Note the 'g' flag implies a stateful regex and is not supported. + /// Other flags are not implemented and are ignored. + #[inline] + pub fn new>(chars: T) -> Self { + let mut result = Self::default(); + for c in chars { + match to_char_sat(c) { + 'm' => { + result.multiline = true; + } + 'i' => { + result.icase = true; + } + 's' => { + result.dot_all = true; + } + 'u' => { + result.unicode = true; + } + 'v' => { + result.unicode_sets = true; + } + _ => { + // Silently skip unsupported flags. + } + } + } + result + } +} + +impl From<&str> for Flags { + /// Construct a Flags from a string, using JavaScript field names. + /// + /// See also: [`Flags::new`]. + #[inline] + fn from(s: &str) -> Self { + Self::new(s.chars().map(u32::from)) + } +} + +impl fmt::Display for Flags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if self.multiline { + f.write_str("m")?; + } + if self.icase { + f.write_str("i")?; + } + if self.dot_all { + f.write_str("s")?; + } + if self.unicode { + f.write_str("u")?; + } + Ok(()) + } +} + +/// Range is used to express the extent of a match, as indexes into the input +/// string. +pub type Range = core::ops::Range; + +/// An iterator type which yields `Match`es found in a string. +pub type Matches<'r, 't> = exec::Matches>; + +/// An iterator type which yields `Match`es found in a string, supporting ASCII +/// only. +pub type AsciiMatches<'r, 't> = exec::Matches>; + +/// A Match represents a portion of a string which was found to match a Regex. +#[derive(Debug, Clone)] +pub struct Match { + /// The total range of the match. Note this may be empty, if the regex + /// matched an empty string. + pub range: Range, + + /// The list of captures. This has length equal to the number of capturing + /// groups in the regex. For each capture, if the value is None, that group + /// did not match (for example, it was in a not-taken branch of an + /// alternation). If the value is Some, the group did match with the + /// enclosed range. + pub captures: Vec>, + + // A list of capture group names. This is either: + // - Empty, if there were no named capture groups. + // - A list of names with length `captures.len()`, corresponding to the + // capture group names in order. Groups without names have an empty string. + pub(crate) group_names: Box<[Box]>, +} + +impl Match { + /// Access a group by index, using the convention of Python's group() + /// function. Index 0 is the total match, index 1 is the first capture + /// group. + #[inline] + pub fn group(&self, idx: usize) -> Option { + if idx == 0 { + Some(self.range.clone()) + } else if idx <= self.captures.len() { + self.captures[idx - 1].clone() + } else { + None + } + } + + /// Access a named group by name. + #[inline] + pub fn named_group(&self, name: &str) -> Option { + // Empty strings are used as sentinels to indicate unnamed group. + if name.is_empty() { + return None; + } + let pos = self.group_names.iter().position(|s| s.as_ref() == name)?; + self.captures[pos].clone() + } + + /// Return an iterator over the named groups of a Match. + #[inline] + pub fn named_groups(&self) -> NamedGroups<'_> { + NamedGroups::new(self) + } + + /// Returns the range over the starting and ending byte offsets of the match in the haystack. + /// + /// This is a convenience function to work around + /// the fact that Range does not support Copy. + #[inline] + pub fn range(&self) -> Range { + self.range.clone() + } + + /// Returns the starting byte offset of the match in the haystack. + #[inline] + pub fn start(&self) -> usize { + self.range.start + } + + /// Returns the ending byte offset of the match in the haystack. + #[inline] + pub fn end(&self) -> usize { + self.range.end + } + + /// Returns the matched text as a string slice. + /// + /// # Examples + /// + /// ```rust + /// use regress::Regex; + /// + /// let re = Regex::new(r"\d+").unwrap(); + /// let text = "Price: $123"; + /// let m = re.find(text).unwrap(); + /// assert_eq!(m.as_str(text), "123"); + /// ``` + #[inline] + pub fn as_str<'t>(&self, text: &'t str) -> &'t str { + &text[self.range()] + } + + /// Return an iterator over a Match. The first returned value is the total + /// match, and subsequent values represent the capture groups. + #[inline] + pub fn groups(&self) -> Groups<'_> { + Groups::new(self) + } +} + +/// An iterator over the capture groups of a [`Match`] +/// +/// This struct is created by the [`groups`] method on [`Match`]. +/// +/// [`Match`]: ../struct.Match.html +/// [`groups`]: ../struct.Match.html#method.groups +#[derive(Clone)] +pub struct Groups<'m> { + mat: &'m Match, + + // The next group index to return, where 0 references the total match. + next_group_idx: usize, + + // The maximum group index to return, with a +1 for the implicit total match. + // For example, in a regex with 1 capture group, this will be 2. + max: usize, +} + +impl<'m> Groups<'m> { + #[inline] + fn new(mat: &'m Match) -> Self { + Self { + mat, + next_group_idx: 0, + max: mat.captures.len() + 1, // +1 for the total match + } + } +} + +impl Iterator for Groups<'_> { + type Item = Option; + + #[inline] + fn next(&mut self) -> Option { + let i = self.next_group_idx; + if i < self.max { + self.next_group_idx += 1; + Some(self.mat.group(i)) + } else { + None + } + } + + fn size_hint(&self) -> (usize, Option) { + let size = self.max.saturating_sub(self.next_group_idx); + (size, Some(size)) + } +} + +impl<'m> ExactSizeIterator for Groups<'m> {} +impl<'m> FusedIterator for Groups<'m> {} + +/// An iterator over the named capture groups of a [`Match`] +/// +/// This struct is created by the [`named_groups`] method on [`Match`]. +/// +/// [`Match`]: ../struct.Match.html +/// [`named_groups`]: ../struct.Match.html#method.named_groups +#[derive(Clone)] +pub struct NamedGroups<'m> { + mat: &'m Match, + + // The next group name index to return. + // Note unlike `Groups` this does NOT include the implicit total match. + // That is, group 0 is the first capture group, NOT the total match. + next_group_idx: usize, +} + +impl<'m> NamedGroups<'m> { + #[inline] + fn new(mat: &'m Match) -> Self { + Self { + mat, + next_group_idx: 0, + } + } +} + +impl<'m> Iterator for NamedGroups<'m> { + type Item = (&'m str, Option); + + #[inline] + fn next(&mut self) -> Option { + // Increment next_group_idx until we find a non-empty name that we haven't seen yet. + debug_assert!(self.next_group_idx <= self.mat.group_names.len()); + let end = self.mat.group_names.len(); + + loop { + let mut idx = self.next_group_idx; + // Skip empty names + while idx < end && self.mat.group_names[idx].is_empty() { + idx += 1; + } + if idx == end { + return None; + } + + let name = self.mat.group_names[idx].as_ref(); + + // Check if we've already returned this name (by looking backwards) + let already_seen = self.mat.group_names[..idx] + .iter() + .any(|n| n.as_ref() == name); + + if already_seen { + // Skip this duplicate and continue to next + self.next_group_idx = idx + 1; + continue; + } + + // This is the first occurrence of this name. Find the best range value. + // Prefer a Some value over None when there are duplicate names. + let mut best_range = self.mat.captures[idx].clone(); + for check_idx in (idx + 1)..end { + if self.mat.group_names[check_idx].as_ref() == name { + // Found a duplicate name. Prefer a Some value over None. + if best_range.is_none() && self.mat.captures[check_idx].is_some() { + best_range = self.mat.captures[check_idx].clone(); + break; // Stop once we find a Some value + } + } + } + + self.next_group_idx = idx + 1; + return Some((name, best_range)); + } + } + + fn size_hint(&self) -> (usize, Option) { + let size = self.mat.group_names[self.next_group_idx..] + .iter() + .filter(|s| !s.is_empty()) + .count(); + + (size, Some(size)) + } +} + +impl<'m> ExactSizeIterator for NamedGroups<'m> {} +impl<'m> FusedIterator for NamedGroups<'m> {} + +/// A Regex is the compiled version of a pattern. +#[derive(Debug, Clone)] +pub struct Regex { + cr: CompiledRegex, +} + +impl From for Regex { + fn from(cr: CompiledRegex) -> Self { + Self { cr } + } +} + +impl Regex { + /// Construct a regex by parsing `pattern` using the default flags. + /// An Error may be returned if the syntax is invalid. + /// Note that this is rather expensive; prefer to cache a Regex which is + /// intended to be used more than once. + #[inline] + pub fn new(pattern: &str) -> Result { + Self::with_flags(pattern, Flags::default()) + } + + /// Construct a regex by parsing `pattern` with `flags`. + /// An Error may be returned if the syntax is invalid. + // + /// Note it is preferable to cache a Regex which is intended to be used more + /// than once, as the parse may be expensive. For example: + #[inline] + pub fn with_flags(pattern: &str, flags: F) -> Result + where + F: Into, + { + Self::from_unicode(pattern.chars().map(u32::from), flags) + } + + /// Construct a regex by parsing `pattern` with `flags`, where + /// `pattern` is an iterator of `u32` Unicode codepoints. + /// An Error may be returned if the syntax is invalid. + /// This allows parsing regular expressions from exotic strings in + /// other encodings, such as UTF-16 or UTF-32. + pub fn from_unicode(pattern: I, flags: F) -> Result + where + I: Iterator + Clone, + F: Into, + { + let flags = flags.into(); + let mut ire = parse::try_parse(pattern, flags)?; + if !flags.no_opt { + optimizer::optimize(&mut ire); + } + let cr = emit::emit(&ire); + Ok(Regex { cr }) + } + + /// Searches `text` to find the first match. + #[inline] + pub fn find(&self, text: &str) -> Option { + self.find_iter(text).next() + } + + /// Searches `text`, returning an iterator over non-overlapping matches. + /// Note that the resulting Iterator borrows both the regex `'r` and the + /// input string as `'t`. + #[inline] + pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> Matches<'r, 't> { + self.find_from(text, 0) + } + + /// Returns an iterator for matches found in 'text' starting at byte index + /// `start`. Note this may be different from passing a sliced `text` in + /// the case of lookbehind assertions. + /// Example: + /// + /// ```rust + /// use regress::Regex; + /// let text = "xyxy"; + /// let re = Regex::new(r"(?<=x)y").unwrap(); + /// let t1 = re.find(&text[1..]).unwrap().range(); + /// assert!(t1 == (2..3)); + /// let t2 = re.find_from(text, 1).next().unwrap().range(); + /// assert!(t2 == (1..2)); + /// ``` + #[inline] + pub fn find_from<'r, 't>(&'r self, text: &'t str, start: usize) -> Matches<'r, 't> { + backends::find(self, text, start) + } + + /// Searches `text` to find the first match. + /// The input text is expected to be ascii-only: only ASCII case-folding is + /// supported. + #[inline] + pub fn find_ascii(&self, text: &str) -> Option { + self.find_iter_ascii(text).next() + } + + /// Searches `text`, returning an iterator over non-overlapping matches. + /// The input text is expected to be ascii-only: only ASCII case-folding is + /// supported. + #[inline] + pub fn find_iter_ascii<'r, 't>(&'r self, text: &'t str) -> AsciiMatches<'r, 't> { + self.find_from_ascii(text, 0) + } + + /// Returns an iterator for matches found in 'text' starting at byte index + /// `start`. + #[inline] + pub fn find_from_ascii<'r, 't>(&'r self, text: &'t str, start: usize) -> AsciiMatches<'r, 't> { + backends::find(self, text, start) + } + + /// Returns an iterator for matches found in 'text' starting at index `start`. + #[cfg(feature = "utf16")] + pub fn find_from_utf16<'r, 't>( + &'r self, + text: &'t [u16], + start: usize, + ) -> exec::Matches>> + { + let input = Utf16Input::new(text, self.cr.flags.unicode); + exec::Matches::new( + super::classicalbacktrack::BacktrackExecutor::new( + input, + MatchAttempter::new(&self.cr, input.left_end()), + ), + start, + ) + } + + /// Returns an iterator for matches found in 'text' starting at index `start`. + #[cfg(feature = "utf16")] + pub fn find_from_ucs2<'r, 't>( + &'r self, + text: &'t [u16], + start: usize, + ) -> exec::Matches>> + { + let input = Ucs2Input::new(text, self.cr.flags.unicode); + exec::Matches::new( + super::classicalbacktrack::BacktrackExecutor::new( + input, + MatchAttempter::new(&self.cr, input.left_end()), + ), + start, + ) + } + + /// Replaces the first match of the regex in `text` with the replacement string. + /// + /// The replacement string may contain capture group references in the form `$1`, `$2`, etc., + /// where `$1` refers to the first capture group, `$2` to the second, and so on. + /// `$0` refers to the entire match. Use `$$` to insert a literal `$`. + /// + /// If no match is found, the original text is returned unchanged. + /// + /// # Examples + /// + /// ```rust + /// use regress::Regex; + /// + /// let re = Regex::new(r"(\w+)\s+(\w+)").unwrap(); + /// let result = re.replace("hello world", "$2 $1"); + /// assert_eq!(result, "world hello"); + /// + /// let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap(); + /// let result = re.replace("2023-12-25", "$2/$3/$1"); + /// assert_eq!(result, "12/25/2023"); + /// ``` + pub fn replace(&self, text: &str, replacement: &str) -> String { + match self.find(text) { + Some(m) => { + let mut result = String::with_capacity(text.len()); + result.push_str(&text[..m.start()]); + self.expand_replacement(&m, text, replacement, &mut result); + result.push_str(&text[m.end()..]); + result + } + None => text.to_string(), + } + } + + /// Replaces all matches of the regex in `text` with the replacement string. + /// + /// The replacement string may contain capture group references in the form `$1`, `$2`, etc., + /// where `$1` refers to the first capture group, `$2` to the second, and so on. + /// `$0` refers to the entire match. Use `$$` to insert a literal `$`. + /// + /// # Examples + /// + /// ```rust + /// use regress::Regex; + /// + /// let re = Regex::new(r"(\w+)\s+(\w+)").unwrap(); + /// let result = re.replace_all("hello world foo bar", "$2-$1"); + /// assert_eq!(result, "world-hello bar-foo"); + /// + /// let re = Regex::new(r"\b(\w)(\w+)").unwrap(); + /// let result = re.replace_all("hello world", "$1.$2"); + /// assert_eq!(result, "h.ello w.orld"); + /// ``` + pub fn replace_all(&self, text: &str, replacement: &str) -> String { + let mut result = String::with_capacity(text.len()); + let mut last_end = 0; + + for m in self.find_iter(text) { + result.push_str(&text[last_end..m.start()]); + self.expand_replacement(&m, text, replacement, &mut result); + last_end = m.end(); + } + + result.push_str(&text[last_end..]); + result + } + + /// Replaces the first match of the regex in `text` using a closure. + /// + /// The closure receives a `&Match` and should return the replacement string. + /// This is useful for dynamic replacements that depend on the match details. + /// + /// If no match is found, the original text is returned unchanged. + /// + /// # Examples + /// + /// ```rust + /// use regress::Regex; + /// + /// let re = Regex::new(r"\d+").unwrap(); + /// let text = "Price: $123"; + /// let result = re.replace_with(text, |m| { + /// let num: i32 = m.as_str(text).parse().unwrap(); + /// format!("{}", num * 2) + /// }); + /// assert_eq!(result, "Price: $246"); + /// ``` + pub fn replace_with(&self, text: &str, replacement: F) -> String + where + F: FnOnce(&Match) -> String, + { + match self.find(text) { + Some(m) => { + let mut result = String::with_capacity(text.len()); + result.push_str(&text[..m.start()]); + result.push_str(&replacement(&m)); + result.push_str(&text[m.end()..]); + result + } + None => text.to_string(), + } + } + + /// Replaces all matches of the regex in `text` using a closure. + /// + /// The closure receives a `&Match` and should return the replacement string. + /// This is useful for dynamic replacements that depend on the match details. + /// + /// # Examples + /// + /// ```rust + /// use regress::Regex; + /// + /// let re = Regex::new(r"\d+").unwrap(); + /// let text = "Items: 5, 10, 15"; + /// let result = re.replace_all_with(text, |m| { + /// let num: i32 = m.as_str(text).parse().unwrap(); + /// format!("[{}]", num * 10) + /// }); + /// assert_eq!(result, "Items: [50], [100], [150]"); + /// ``` + pub fn replace_all_with(&self, text: &str, replacement: F) -> String + where + F: Fn(&Match) -> String, + { + let mut result = String::with_capacity(text.len()); + let mut last_end = 0; + + for m in self.find_iter(text) { + result.push_str(&text[last_end..m.start()]); + result.push_str(&replacement(&m)); + last_end = m.end(); + } + + result.push_str(&text[last_end..]); + result + } + + /// Helper method to expand replacement strings with capture group substitutions. + fn expand_replacement(&self, m: &Match, text: &str, replacement: &str, output: &mut String) { + let mut chars = replacement.chars().peekable(); + + while let Some(ch) = chars.next() { + if ch == '$' { + match chars.peek() { + Some('$') => { + // $$ -> literal $ + chars.next(); + output.push('$'); + } + Some(&digit) if digit.is_ascii_digit() => { + // Parse the group number + let mut group_num = 0; + while let Some(&digit) = chars.peek() { + if digit.is_ascii_digit() { + chars.next(); + group_num = group_num * 10 + (digit as u32 - '0' as u32) as usize; + // Limit to reasonable group numbers to avoid overflow + if group_num > MAX_CAPTURE_GROUPS { + break; + } + } else { + break; + } + } + + // Get the matched text for this group + if let Some(range) = m.group(group_num) { + output.push_str(&text[range]); + } + // If group doesn't exist or didn't match, add nothing + } + Some('{') => { + // Handle ${name} syntax for named groups + chars.next(); // consume '{' + let mut name = String::new(); + let mut found_closing_brace = false; + + for ch in chars.by_ref() { + if ch == '}' { + found_closing_brace = true; + break; + } + name.push(ch); + } + + if found_closing_brace { + if let Some(range) = m.named_group(&name) { + output.push_str(&text[range]); + } + } else { + // Malformed ${...}, treat as literal + output.push_str("${"); + output.push_str(&name); + } + } + _ => { + // Just a $ at end or followed by non-digit + output.push('$'); + } + } + } else { + output.push(ch); + } + } + } +} + +impl FromStr for Regex { + type Err = Error; + + /// Attempts to parse a string into a regular expression + #[inline] + fn from_str(s: &str) -> Result { + Self::new(s) + } +} + +// Pattern trait implementation for str::find, str::contains, etc. +#[cfg(feature = "pattern")] +mod pattern_impl { + use super::*; + use core::str::pattern::{Pattern, ReverseSearcher, SearchStep, Searcher}; + + /// A searcher for a regex pattern. + pub struct RegexSearcher<'r, 't> { + haystack: &'t str, + regex: &'r Regex, + current_pos: usize, + done: bool, + // For reverse searching + reverse_pos: usize, + reverse_done: bool, + } + + impl<'r, 't> RegexSearcher<'r, 't> { + fn new(regex: &'r Regex, haystack: &'t str) -> Self { + Self { + haystack, + regex, + current_pos: 0, + done: false, + reverse_pos: haystack.len(), + reverse_done: false, + } + } + + fn find_last_match_before(&self, pos: usize) -> Option { + // Find all matches up to the given position and return the last one + let mut last_match = None; + for m in self.regex.find_from(self.haystack, 0) { + if m.end() <= pos { + last_match = Some(m); + } else { + break; + } + } + last_match + } + } + + unsafe impl<'r, 't> Searcher<'t> for RegexSearcher<'r, 't> { + fn haystack(&self) -> &'t str { + self.haystack + } + + fn next(&mut self) -> SearchStep { + if self.done { + return SearchStep::Done; + } + + // Try to find the next match starting from current position + if let Some(m) = self.regex.find_from(self.haystack, self.current_pos).next() { + let match_start = m.start(); + let match_end = m.end(); + + // Handle any gap between current position and match start + if self.current_pos < match_start { + let reject_end = match_start; + let reject_start = self.current_pos; + self.current_pos = match_start; + return SearchStep::Reject(reject_start, reject_end); + } + + // Return the match + self.current_pos = match_end; + + // Handle zero-width matches to avoid infinite loops + if match_start == match_end { + // For zero-width matches, we need to advance at least one byte + // to avoid infinite loops + if match_end < self.haystack.len() { + // Find the next character boundary + let mut next_pos = match_end + 1; + while next_pos < self.haystack.len() + && !self.haystack.is_char_boundary(next_pos) + { + next_pos += 1; + } + self.current_pos = next_pos; + } else { + // We're at the end of the string + self.done = true; + } + } + + SearchStep::Match(match_start, match_end) + } else { + // No more matches, reject remaining text if any + if self.current_pos < self.haystack.len() { + let reject_start = self.current_pos; + let reject_end = self.haystack.len(); + self.current_pos = self.haystack.len(); + self.done = true; + SearchStep::Reject(reject_start, reject_end) + } else { + self.done = true; + SearchStep::Done + } + } + } + } + + unsafe impl<'r, 't> ReverseSearcher<'t> for RegexSearcher<'r, 't> { + fn next_back(&mut self) -> SearchStep { + if self.reverse_done { + return SearchStep::Done; + } + + // Try to find the last match before current reverse position + if let Some(m) = self.find_last_match_before(self.reverse_pos) { + let match_start = m.start(); + let match_end = m.end(); + + // Handle any gap between match end and current reverse position + if match_end < self.reverse_pos { + let reject_start = match_end; + let reject_end = self.reverse_pos; + self.reverse_pos = match_end; + return SearchStep::Reject(reject_start, reject_end); + } + + // Return the match + self.reverse_pos = match_start; + + // Handle zero-width matches + if match_start == match_end { + // For zero-width matches, move back by one character + if match_start > 0 { + let mut prev_pos = match_start - 1; + while prev_pos > 0 && !self.haystack.is_char_boundary(prev_pos) { + prev_pos -= 1; + } + self.reverse_pos = prev_pos; + } else { + // We're at the beginning of the string + self.reverse_done = true; + } + } + + SearchStep::Match(match_start, match_end) + } else { + // No more matches, reject remaining text if any + if self.reverse_pos > 0 { + let reject_start = 0; + let reject_end = self.reverse_pos; + self.reverse_pos = 0; + self.reverse_done = true; + SearchStep::Reject(reject_start, reject_end) + } else { + self.reverse_done = true; + SearchStep::Done + } + } + } + } + + impl<'r> Pattern for &'r Regex { + type Searcher<'a> = RegexSearcher<'r, 'a>; + + fn into_searcher(self, haystack: &str) -> Self::Searcher<'_> { + RegexSearcher::new(self, haystack) + } + } +} + +#[cfg(feature = "pattern")] +pub use pattern_impl::*; + +// Support for using regress with different regex backends. +// Currently there is only the classical backtracking, and PikeVM. +#[doc(hidden)] +pub mod backends { + use super::Regex; + use super::exec; + use super::indexing; + pub use crate::emit::emit; + pub use crate::optimizer::optimize; + pub use crate::parse::try_parse; + + /// An Executor using the classical backtracking algorithm. + pub type BacktrackExecutor<'r, 't> = + super::classicalbacktrack::BacktrackExecutor<'r, indexing::Utf8Input<'t>>; + + /// A Executor using the PikeVM executor. + #[cfg(feature = "backend-pikevm")] + pub type PikeVMExecutor<'r, 't> = super::pikevm::PikeVMExecutor<'r, indexing::Utf8Input<'t>>; + + /// An alias type to the default Executor. + pub type DefaultExecutor<'r, 't> = BacktrackExecutor<'r, 't>; + + /// An alias type to the default executor's ASCII form. + pub type DefaultAsciiExecutor<'r, 't> = + as exec::Executor<'r, 't>>::AsAscii; + + /// Searches `text`, returning an iterator over non-overlapping matches. + pub fn find<'r, 't, Executor: exec::Executor<'r, 't>>( + re: &'r Regex, + text: &'t str, + start: usize, + ) -> exec::Matches { + exec::Matches::new(Executor::new(&re.cr, text), start) + } + + /// Searches `text`, returning an iterator over non-overlapping matches. + /// This is a convenience method to avoid E0223. + pub fn find_ascii<'r, 't, Executor: exec::Executor<'r, 't>>( + re: &'r Regex, + text: &'t str, + start: usize, + ) -> exec::Matches { + find::(re, text, start) + } +} + +/// Escapes all special regex characters in a string to make it a literal match. +/// +/// This function takes a string and returns a new string with all special +/// regex characters escaped with backslashes, so the resulting string can be +/// used as a literal pattern in a regular expression. +/// +/// # Example +/// +/// ``` +/// use regress::escape; +/// +/// let escaped = escape("Hello. How are you?"); +/// assert_eq!(escaped, "Hello\\. How are you\\?"); +/// +/// let escaped = escape("$100 + tax (15%)"); +/// assert_eq!(escaped, "\\$100 \\+ tax \\(15%\\)"); +/// ``` +pub fn escape(text: &str) -> String { + let mut result = String::with_capacity(text.len()); + + for c in text.chars() { + match c { + // Characters that have special meaning in regex and need escaping + '\\' | '^' | '$' | '.' | '|' | '?' | '*' | '+' | '(' | ')' | '[' | ']' | '{' | '}' => { + result.push('\\'); + result.push(c); + } + // All other characters are literal + _ => result.push(c), + } + } + + result +} diff --git a/third_party/regress/src/bytesearch.rs b/third_party/regress/src/bytesearch.rs new file mode 100644 index 00000000..0f65f892 --- /dev/null +++ b/third_party/regress/src/bytesearch.rs @@ -0,0 +1,389 @@ +use crate::insn::MAX_CHAR_SET_LENGTH; +use core::fmt; +extern crate memchr; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; + +/// Facilities for searching bytes. +pub trait ByteSearcher { + /// Search for ourselves in a slice of bytes. + /// The length of the slice is unspecified and may be 0. + /// \return the next index of ourselves in the slice, or None. + fn find_in(&self, rhs: &[u8]) -> Option; +} + +impl ByteSearcher for [u8; 1] { + #[inline(always)] + fn find_in(&self, rhs: &[u8]) -> Option { + memchr::memchr(self[0], rhs) + } +} + +impl ByteSearcher for [u8; 2] { + #[inline(always)] + fn find_in(&self, rhs: &[u8]) -> Option { + memchr::memchr2(self[0], self[1], rhs) + } +} + +impl ByteSearcher for [u8; 3] { + #[inline(always)] + fn find_in(&self, rhs: &[u8]) -> Option { + memchr::memchr3(self[0], self[1], self[2], rhs) + } +} + +impl ByteSearcher for memchr::memmem::Finder<'_> { + fn find_in(&self, rhs: &[u8]) -> Option { + self.find(rhs) + } +} + +/// A ByteSet is any set of bytes. +pub trait ByteSet { + /// \return whether the ByteSet contains the byte. + fn contains(&self, b: u8) -> bool; +} + +/// A ByteArraySet wraps a small array and uses linear equality. +#[derive(Copy, Clone, Debug)] +#[repr(align(4))] +pub struct ByteArraySet(pub ArraySet); + +/// Cover over contains() to avoid bumping into native contains call. +impl ByteArraySet { + #[inline(always)] + pub fn contains(self, b: u8) -> bool { + self.0.contains(b) + } +} + +impl ByteSearcher for ByteArraySet { + #[inline(always)] + fn find_in(&self, rhs: &[u8]) -> Option { + self.0.find_in(rhs) + } +} + +/// A SmallArraySet is a set implemented as a small byte array. +pub trait SmallArraySet: Copy { + fn contains(self, b: u8) -> bool; + + fn find_in(self, rhs: &[u8]) -> Option; +} + +// Beware: Rust is cranky about loop unrolling. +// Do not try to be too clever here. +impl SmallArraySet for [u8; 2] { + #[inline(always)] + fn contains(self, b: u8) -> bool { + b == self[0] || b == self[1] + } + + #[inline(always)] + fn find_in(self, rhs: &[u8]) -> Option { + memchr::memchr2(self[0], self[1], rhs) + } +} +impl SmallArraySet for [u8; 3] { + #[inline(always)] + fn contains(self, b: u8) -> bool { + b == self[0] || b == self[1] || b == self[2] + } + + #[inline(always)] + fn find_in(self, rhs: &[u8]) -> Option { + memchr::memchr3(self[0], self[1], self[2], rhs) + } +} +impl SmallArraySet for [u8; 4] { + #[inline(always)] + fn contains(self, b: u8) -> bool { + b == self[0] || b == self[1] || b == self[2] || b == self[3] + } + + #[inline(always)] + fn find_in(self, rhs: &[u8]) -> Option { + // TODO. + for (idx, byte) in rhs.iter().enumerate() { + if self.contains(*byte) { + return Some(idx); + } + } + None + } +} + +// CharSet helper. Avoid branching in the loop to get good unrolling. +#[allow(unused_parens)] +#[inline(always)] +pub fn charset_contains(set: &[u32; MAX_CHAR_SET_LENGTH], c: u32) -> bool { + let mut result = false; + for &v in set.iter() { + result |= (v == c); + } + result +} + +/// A helper function for formatting bitmaps, using - ranges. +fn format_bitmap(name: &str, f: &mut fmt::Formatter<'_>, contains: Func) -> fmt::Result +where + Func: Fn(u8) -> bool, +{ + write!(f, "{}[", name)?; + let mut idx = 0; + let mut maybe_space = ""; + while idx <= 256 { + // Compute the next value not contained. + let mut end = idx; + while end <= 256 && contains(end as u8) { + end += 1; + } + match end - idx { + 0 => (), + 1 => write!(f, "{}{}", maybe_space, idx)?, + _ => write!(f, "{}{}-{}", maybe_space, idx, end - 1)?, + }; + if end > idx { + maybe_space = " "; + } + idx = end + 1 + } + write!(f, "]")?; + Ok(()) +} + +/// A bitmap covering ASCII characters. +#[derive(Default, Copy, Clone)] +#[repr(align(4))] +pub struct AsciiBitmap(pub [u8; 16]); + +impl AsciiBitmap { + /// Set a byte val in this bitmap. + #[inline(always)] + pub fn set(&mut self, val: u8) { + debug_assert!(val <= 127, "Value should be ASCII"); + self.0[(val >> 3) as usize] |= 1 << (val & 0x7); + } +} + +impl fmt::Debug for AsciiBitmap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + format_bitmap("AsciiBitmap", f, |v| self.contains(v)) + } +} + +impl ByteSet for AsciiBitmap { + /// \return whether this bitmap contains a given value. + /// The value does NOT have to be ASCII. + #[inline(always)] + fn contains(&self, val: u8) -> bool { + // Delicate tricks to avoid branches. + // In general we want to compute the byte via /8, and then mask into the + // byte. But if the value is not ASCII then the byte could be too large. + // So mask off the MSB so that the byte is always in range. + let byte = (val & 0x7F) >> 3; + let bit = val & 0x7; + + // Now probe the bitmap. If our sign bit was set, we want the mask to be 0; + // otherwise we want to set only the 'bit' offset. + // Invert the sign bit and reuse it. + let mask = ((val >> 7) ^ 1) << bit; + + // Probe the bitmap. We expect the compiler to elide the bounds check. + (self.0[byte as usize] & mask) != 0 + } +} + +/// A bitmap covering all bytes. +#[derive(Default, Copy, Clone, PartialEq, Eq)] +#[repr(align(4))] +pub struct ByteBitmap([u16; 16]); + +// TODO: the codegen here is pretty horrible; LLVM is emitting a sequence of +// halfword instructions. Consider using a union? +impl ByteBitmap { + /// Construct from a sequence of bytes. + pub fn new(bytes: &[u8]) -> ByteBitmap { + let mut bb = ByteBitmap::default(); + for &b in bytes { + bb.set(b) + } + bb + } + + /// \return whether this bitmap contains a given byte val. + #[inline(always)] + pub fn contains(&self, val: u8) -> bool { + let byte = val >> 4; + let bit = val & 0xF; + (self.0[byte as usize] & (1 << bit)) != 0 + } + + /// Set a bit in this bitmap. + #[inline(always)] + pub fn set(&mut self, val: u8) { + let byte = val >> 4; + let bit = val & 0xF; + self.0[byte as usize] |= 1 << bit; + } + + /// Update ourselves from another bitmap, in place. + pub fn bitor(&mut self, rhs: &ByteBitmap) { + for idx in 0..self.0.len() { + self.0[idx] |= rhs.0[idx]; + } + } + + /// Invert our bits, in place. + pub fn bitnot(&mut self) -> &mut Self { + for val in self.0.iter_mut() { + *val = !*val; + } + self + } + + /// Count number of set bits. + pub fn count_bits(&self) -> u32 { + self.0.iter().map(|v| v.count_ones()).sum() + } + + /// Return ourselves as an array of a fixed length. + /// Panics if the array is not large enough. + #[allow(clippy::wrong_self_convention)] + #[inline(always)] + pub fn as_array(&self) -> [u8; N] { + let mut array = [0u8; N]; + let mut idx = 0; + for byte in 0..=255 { + if self.contains(byte) { + array[idx] = byte; + idx += 1; + } + } + array + } + + /// \return the index of the first byte in the slice that is present in this + /// bitmap, using some unsafe tricks. + #[inline(always)] + fn unsafe_find_in_slice(&self, bytes: &[u8]) -> Option { + type Chunk = u32; + let bm = &self.0; + + let mut offset = 0; + let (prefix, body, suffix) = unsafe { bytes.align_to::() }; + for &byte in prefix.iter() { + if self.contains(byte) { + return Some(offset); + } + offset += 1; + } + + for &chunk in body { + // Use LE. Here index 0 is the earliest address. + let byte_idxs = ((chunk >> 4) & 0x0F0F0F0F).to_le_bytes(); + let bit_idxs = (chunk & 0x0F0F0F0F).to_le_bytes(); + if (bm[byte_idxs[0] as usize] & (1 << bit_idxs[0])) != 0 { + return Some(offset); + } + if (bm[byte_idxs[1] as usize] & (1 << bit_idxs[1])) != 0 { + return Some(offset + 1); + } + if (bm[byte_idxs[2] as usize] & (1 << bit_idxs[2])) != 0 { + return Some(offset + 2); + } + if (bm[byte_idxs[3] as usize] & (1 << bit_idxs[3])) != 0 { + return Some(offset + 3); + } + offset += 4; + } + + for &byte in suffix.iter() { + if self.contains(byte) { + return Some(offset); + } + offset += 1; + } + None + } +} + +impl ByteSearcher for ByteBitmap { + #[inline(always)] + fn find_in(&self, bytes: &[u8]) -> Option { + if cfg!(feature = "prohibit-unsafe") { + for (idx, byte) in bytes.iter().enumerate() { + if self.contains(*byte) { + return Some(idx); + } + } + None + } else { + self.unsafe_find_in_slice(bytes) + } + } +} + +impl fmt::Debug for ByteBitmap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + format_bitmap("ByteBitmap", f, |v| self.contains(v)) + } +} + +/// A trivial ByteSearcher corresponding to the empty string. +#[derive(Debug, Copy, Clone)] +pub struct EmptyString {} + +impl ByteSearcher for EmptyString { + #[inline(always)] + fn find_in(&self, _bytes: &[u8]) -> Option { + Some(0) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn make_bitmap(bytes: &[u8]) -> ByteBitmap { + let mut bm = ByteBitmap::default(); + for &b in bytes { + bm.set(b) + } + bm + } + + #[test] + fn empty_search() { + assert_eq!(EmptyString {}.find_in(&[1, 2, 3]), Some(0)); + assert_eq!(EmptyString {}.find_in(&[]), Some(0)); + } + + #[test] + fn bitmap_search() { + assert_eq!(make_bitmap(&[]).find_in(&[1, 2, 3]), None); + assert_eq!(make_bitmap(&[]).bitnot().find_in(&[1, 2, 3]), Some(0)); + assert_eq!(make_bitmap(&[1]).bitnot().find_in(&[1, 2, 3]), Some(1)); + assert_eq!(make_bitmap(&[2]).bitnot().find_in(&[1, 2, 3]), Some(0)); + assert_eq!( + make_bitmap(&[4, 5, 6, 7]).find_in(&[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]), + None + ); + assert_eq!( + make_bitmap(&[4, 5, 6, 7]).find_in(&[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]), + None + ); + assert_eq!( + make_bitmap(&[4, 5, 6, 7]) + .find_in(&[8, 9, 10, 11, 12, 13, 4, 14, 6, 15, 7, 16, 17, 18, 19, 20]), + Some(6) + ); + } + + #[test] + fn literal_search() { + assert_eq!([0, 1, 2, 3].find_in(&[4, 5, 6, 7]), None); + assert_eq!([0, 1, 2, 3].find_in(&[]), None); + } +} diff --git a/third_party/regress/src/charclasses.rs b/third_party/regress/src/charclasses.rs new file mode 100644 index 00000000..9e809356 --- /dev/null +++ b/third_party/regress/src/charclasses.rs @@ -0,0 +1,81 @@ +use crate::codepointset::Interval; + +// Character classes like \d or \S. + +/// Construct an interval from an inclusive range of char. +const fn r(first: char, last: char) -> Interval { + Interval { + first: first as u32, + last: last as u32, + } +} + +/// Construct an interval from a single char. +const fn r1(c: char) -> Interval { + Interval { + first: c as u32, + last: c as u32, + } +} + +// Note all of these are sorted. + +/// ES9 21.2.2.6.1. +pub const WORD_CHARS: [Interval; 4] = [r('0', '9'), r('A', 'Z'), r1('_'), r('a', 'z')]; + +/// ES9 21.2.2.12 +pub const DIGITS: [Interval; 1] = [r('0', '9')]; + +/// [`ES13 12.2 White Space`][spec] +/// +/// [spec]: https://262.ecma-international.org/13.0/#prod-WhiteSpace +pub const WHITESPACE: [Interval; 9] = [ + // U+0009 - Character Tabulation - + // U+000B - Line Tabulation - + // U+000C - Form Feed (FF) - + r('\u{0009}', '\u{000C}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+0020 - Space - + r1('\u{0020}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+00A0 - No-Break Space - + r1('\u{00A0}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+1680 - Ogham Space Mark + r1('\u{1680}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+2000 - En Quad + // U+2001 - Em Quad + // U+2002 - En Space + // U+2003 - Em Space + // U+2004 - Three-Per-Em Space + // U+2005 - Four-Per-Em Space + // U+2006 - Six-Per-Em Space + // U+2007 - Figure Space + // U+2008 - Punctuation Space + // U+2009 - Thin Space + // U+200A - Hair Space + r('\u{2000}', '\u{200A}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+202F - Narrow No-Break Space - + r1('\u{202F}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+205F - Medium Mathematical Space - + r1('\u{205F}'), + // From unicode “Space_Separator” (`Zs`) category: + // + // U+3000 - Ideographic Space + r1('\u{3000}'), + // U+FEFF - ZERO WIDTH NO-BREAK SPACE - + r1('\u{FEFF}'), +]; + +/// ES9 11.3 +pub const LINE_TERMINATOR: [Interval; 3] = + [r1('\u{000A}'), r1('\u{000D}'), r('\u{2028}', '\u{2029}')]; diff --git a/third_party/regress/src/classicalbacktrack.rs b/third_party/regress/src/classicalbacktrack.rs new file mode 100644 index 00000000..9f744640 --- /dev/null +++ b/third_party/regress/src/classicalbacktrack.rs @@ -0,0 +1,1172 @@ +//! Classical backtracking execution engine + +use crate::api::Match; +use crate::bytesearch; +use crate::cursor; +use crate::cursor::{Backward, Direction, Forward}; +use crate::exec; +use crate::indexing; +use crate::indexing::{AsciiInput, ElementType, InputIndexer, Utf8Input}; +#[cfg(not(feature = "utf16"))] +use crate::insn::StartPredicate; +use crate::insn::{CompiledRegex, Insn, LoopFields}; +use crate::matchers; +use crate::matchers::CharProperties; +use crate::position::PositionType; +use crate::scm; +use crate::scm::SingleCharMatcher; +use crate::types::{CaptureGroupID, GroupData, IP, LoopData, LoopID, MAX_CAPTURE_GROUPS}; +use crate::util::DebugCheckIndex; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; +use core::ops::Range; + +#[derive(Clone, Debug)] +enum BacktrackInsn { + /// Nothing more to backtrack. + /// This "backstops" our stack. + Exhausted, + + /// Restore the IP and position. + SetPosition { ip: IP, pos: Input::Position }, + + SetLoopData { + id: LoopID, + data: LoopData, + }, + + SetCaptureGroup { + id: CaptureGroupID, + data: GroupData, + }, + + EnterNonGreedyLoop { + // The IP of the loop. + // This is guaranteed to point to an EnterLoopInsn. + ip: IP, + // The input position of the loop before entering it. + // This is used to set up backtracking that restores this position. + orig_pos: Input::Position, + data: LoopData, + }, + + GreedyLoop1Char { + continuation: IP, + min: Input::Position, + max: Input::Position, + }, + + NonGreedyLoop1Char { + continuation: IP, + min: Input::Position, + max: Input::Position, + }, +} + +#[derive(Debug, Default)] +struct State { + loops: Vec>, + groups: Vec>, +} + +#[derive(Debug)] +pub(crate) struct MatchAttempter<'a, Input: InputIndexer> { + re: &'a CompiledRegex, + bts: Vec>, + s: State, +} + +impl<'a, Input: InputIndexer> MatchAttempter<'a, Input> { + pub(crate) fn new(re: &'a CompiledRegex, entry: Input::Position) -> Self { + Self { + re, + bts: vec![BacktrackInsn::Exhausted], + s: State { + loops: vec![LoopData::new(entry); re.loops as usize], + groups: vec![GroupData::new(); re.groups as usize], + }, + } + } + + #[inline(always)] + fn push_backtrack(&mut self, bt: BacktrackInsn) { + self.bts.push(bt) + } + + #[inline(always)] + fn pop_backtrack(&mut self) { + // Note we never pop the last instruction so this will never be empty. + debug_assert!(!self.bts.is_empty()); + if cfg!(feature = "prohibit-unsafe") { + self.bts.pop(); + } else { + unsafe { self.bts.set_len(self.bts.len() - 1) } + } + } + + fn prepare_to_enter_loop( + bts: &mut Vec>, + pos: Input::Position, + loop_fields: &LoopFields, + loop_data: &mut LoopData, + ) { + bts.push(BacktrackInsn::SetLoopData { + id: loop_fields.loop_id, + data: *loop_data, + }); + loop_data.iters += 1; + loop_data.entry = pos; + } + + fn run_loop( + &mut self, + loop_fields: &'a LoopFields, + pos: Input::Position, + ip: IP, + ) -> Option { + let loop_data = &mut self.s.loops[loop_fields.loop_id as usize]; + let iteration = loop_data.iters; + + let do_taken = iteration < loop_fields.max_iters; + let do_not_taken = iteration >= loop_fields.min_iters; + + let loop_taken_ip = ip + 1; + let loop_not_taken_ip = loop_fields.exit as IP; + + // If we have looped more than the minimum number of iterations, reject empty + // matches. ES6 21.2.2.5.1 Note 4: "once the minimum number of + // repetitions has been satisfied, any more expansions of Atom that match the + // empty character sequence are not considered for further repetitions." + if loop_data.entry == pos && iteration > loop_fields.min_iters { + return None; + } + + match (do_taken, do_not_taken) { + (false, false) => { + // No arms viable. + None + } + (false, true) => { + // Only skipping is viable. + Some(loop_not_taken_ip) + } + (true, false) => { + // Only entering is viable. + MatchAttempter::prepare_to_enter_loop(&mut self.bts, pos, loop_fields, loop_data); + Some(loop_taken_ip) + } + (true, true) if !loop_fields.greedy => { + // Both arms are viable; backtrack into the loop. + let orig_pos = loop_data.entry; + loop_data.entry = pos; + self.bts.push(BacktrackInsn::EnterNonGreedyLoop { + ip, + orig_pos, + data: *loop_data, + }); + Some(loop_not_taken_ip) + } + (true, true) => { + debug_assert!(loop_fields.greedy, "Should be greedy"); + // Both arms are viable; backtrack out of the loop. + self.bts.push(BacktrackInsn::SetPosition { + ip: loop_not_taken_ip, + pos, + }); + MatchAttempter::prepare_to_enter_loop(&mut self.bts, pos, loop_fields, loop_data); + Some(loop_taken_ip) + } + } + } + + // Drive the loop up to \p max times. + // \return the position (min, max), or None on failure. + #[inline(always)] + fn run_scm_loop_impl>( + input: &Input, + mut pos: Input::Position, + min: usize, + max: usize, + dir: Dir, + matcher: Scm, + ) -> Option<(Input::Position, Input::Position)> { + debug_assert!(min <= max, "min should be <= max"); + // Drive the iteration min times. + // That tells us the min position. + for _ in 0..min { + if !matcher.matches(input, dir, &mut pos) { + return None; + } + } + let min_pos = pos; + + // Drive it up to the max. + for _ in 0..(max - min) { + let saved = pos; + if !matcher.matches(input, dir, &mut pos) { + pos = saved; + break; + } + } + let max_pos = pos; + Some((min_pos, max_pos)) + } + + // Compute the maximum position from a starting position, up to a limit. + // This is used for lazy computation in non-greedy loops. + fn compute_max_pos>( + input: &Input, + mut pos: Input::Position, + limit: usize, + dir: Dir, + matcher: Scm, + ) -> Input::Position { + for _ in 0..limit { + let saved = pos; + if !matcher.matches(input, dir, &mut pos) { + pos = saved; + break; + } + } + pos + } + + // Helper function to extract the duplicated match blocks that handle different instruction types + // with different matcher functions. This significantly reduces code duplication and compile times. + fn with_scm_loop_impl( + re: &CompiledRegex, + input: &Input, + pos: Input::Position, + min: usize, + max: usize, + dir: Dir, + ip: IP, + ) -> Option<(Input::Position, Input::Position)> { + match re.insns.iat(ip + 1) { + &Insn::Char(c) => { + let c = <::Element as ElementType>::try_from(c)?; + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::Char { c }) + } + &Insn::CharICase(c) => { + let c = <::Element as ElementType>::try_from(c)?; + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::CharICase { c }) + } + &Insn::Bracket(idx) => { + let bc = &re.brackets[idx]; + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::Bracket { bc }) + } + Insn::AsciiBracket(bitmap) => Self::run_scm_loop_impl( + input, + pos, + min, + max, + dir, + scm::MatchByteSet { bytes: bitmap }, + ), + Insn::MatchAny => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchAny::new()) + } + Insn::MatchAnyExceptLineTerminator => Self::run_scm_loop_impl( + input, + pos, + min, + max, + dir, + scm::MatchAnyExceptLineTerminator::new(), + ), + Insn::CharSet(chars) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::CharSet { chars }) + } + &Insn::ByteSet2(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteArraySet(bytes)) + } + &Insn::ByteSet3(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteArraySet(bytes)) + } + &Insn::ByteSet4(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteArraySet(bytes)) + } + Insn::ByteSeq1(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq2(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq3(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq4(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq5(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq6(bytes) => { + Self::run_scm_loop_impl(input, pos, min, max, dir, scm::MatchByteSeq(bytes)) + } + _ => { + unreachable!("Missing SCM: {:?}", re.insns.iat(ip + 1)); + } + } + } + + // Helper function for compute_max_pos to avoid duplication + fn with_scm_compute_max( + re: &CompiledRegex, + input: &Input, + pos: Input::Position, + limit: usize, + dir: Dir, + ip: IP, + ) -> Option { + let result = match re.insns.iat(ip + 1) { + &Insn::Char(c) => { + let c = <::Element as ElementType>::try_from(c)?; + Self::compute_max_pos(input, pos, limit, dir, scm::Char { c }) + } + &Insn::CharICase(c) => { + let c = <::Element as ElementType>::try_from(c)?; + Self::compute_max_pos(input, pos, limit, dir, scm::CharICase { c }) + } + &Insn::Bracket(idx) => { + let bc = &re.brackets[idx]; + Self::compute_max_pos(input, pos, limit, dir, scm::Bracket { bc }) + } + Insn::AsciiBracket(bitmap) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSet { bytes: bitmap }) + } + Insn::MatchAny => Self::compute_max_pos(input, pos, limit, dir, scm::MatchAny::new()), + Insn::MatchAnyExceptLineTerminator => Self::compute_max_pos( + input, + pos, + limit, + dir, + scm::MatchAnyExceptLineTerminator::new(), + ), + Insn::CharSet(chars) => { + Self::compute_max_pos(input, pos, limit, dir, scm::CharSet { chars }) + } + &Insn::ByteSet2(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteArraySet(bytes)) + } + &Insn::ByteSet3(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteArraySet(bytes)) + } + &Insn::ByteSet4(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteArraySet(bytes)) + } + Insn::ByteSeq1(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq2(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq3(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq4(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq5(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSeq(bytes)) + } + Insn::ByteSeq6(bytes) => { + Self::compute_max_pos(input, pos, limit, dir, scm::MatchByteSeq(bytes)) + } + _ => { + unreachable!("Missing SCM: {:?}", re.insns.iat(ip + 1)); + } + }; + Some(result) + } + + // Given that ip points at a loop whose body matches exactly one character, run + // a "single character loop". The big idea here is that we don't need to save + // our position every iteration: we know that our loop body matches a single + // character so we can backtrack by matching a character backwards. + // \return the next IP, or None if the loop failed. + #[allow(clippy::too_many_arguments)] + fn run_scm_loop( + &mut self, + input: &Input, + dir: Dir, + pos: &mut Input::Position, + min: usize, + max: usize, + ip: IP, + greedy: bool, + ) -> Option { + // For non-greedy loops, we can avoid computing the maximum match eagerly. + // We'll only compute it when we need to set up backtracking. + let (min_pos, max_pos) = if greedy { + // For greedy loops, compute both min and max positions + Self::with_scm_loop_impl(self.re, input, *pos, min, max, dir, ip)? + } else { + // For non-greedy loops, initially only compute the minimum position + let (min_pos, _) = Self::with_scm_loop_impl(self.re, input, *pos, min, min, dir, ip)?; + + // For non-greedy loops, we only compute the max position if we need to set up backtracking + let max_pos = if min < max { + // We need to compute the max for backtracking purposes + Self::with_scm_compute_max(self.re, input, min_pos, max - min, dir, ip)? + } else { + min_pos + }; + (min_pos, max_pos) + }; + + debug_assert!( + if Dir::FORWARD { + min_pos <= max_pos + } else { + min_pos >= max_pos + }, + "min should be <= (>=) max if cursor is tracking forwards (backwards)" + ); + + // Oh no where is the continuation? It's one past the loop body, which is one + // past the loop. Strap in! + let continuation = ip + 2; + if min_pos != max_pos { + // Backtracking is possible. + let bti = if greedy { + BacktrackInsn::GreedyLoop1Char { + continuation, + min: min_pos, + max: max_pos, + } + } else { + BacktrackInsn::NonGreedyLoop1Char { + continuation, + min: min_pos, + max: max_pos, + } + }; + self.bts.push(bti); + } + + // Start at the max (min) if greedy (nongreedy). + *pos = if greedy { max_pos } else { min_pos }; + Some(continuation) + } + + // Run a lookaround instruction, which is either forwards or backwards + // (according to Direction). The half-open range + // start_group..end_group is the range of contained capture groups. + // \return whether we matched and negate was false, or did not match but negate + // is true. + fn run_lookaround( + &mut self, + input: &Input, + ip: IP, + pos: Input::Position, + start_group: CaptureGroupID, + end_group: CaptureGroupID, + negate: bool, + ) -> bool { + // Copy capture groups, because if the match fails (or if we are inverted) + // we need to restore these. + let range = (start_group as usize)..(end_group as usize); + // TODO: consider retaining storage here? + // Temporarily defeat backtracking. + let saved_groups = self.s.groups.iat(range.clone()).to_vec(); + + // Start with an "empty" backtrack stack. + // TODO: consider using a stack-allocated array. + let mut saved_bts = vec![BacktrackInsn::Exhausted]; + core::mem::swap(&mut self.bts, &mut saved_bts); + + // Enter into the lookaround's instruction stream. + let matched = self.try_at_pos(*input, ip, pos, Dir::new()).is_some(); + + // Put back our bts. + core::mem::swap(&mut self.bts, &mut saved_bts); + + // If we are a positive lookahead that successfully matched, retain the + // capture groups (but we need to set up backtracking). Otherwise restore + // them. + if matched && !negate { + for (idx, cg) in saved_groups.iter().enumerate() { + debug_assert!(idx + (start_group as usize) < MAX_CAPTURE_GROUPS); + self.push_backtrack(BacktrackInsn::SetCaptureGroup { + id: (idx as CaptureGroupID) + start_group, + data: *cg, + }); + } + } else { + self.s.groups.splice(range, saved_groups); + } + matched != negate + } + + /// Attempt to backtrack. + /// \return true if we backtracked, false if we exhaust the backtrack stack. + fn try_backtrack( + &mut self, + input: &Input, + ip: &mut IP, + pos: &mut Input::Position, + _dir: Dir, + ) -> bool { + loop { + // We always have a single Exhausted instruction backstopping our stack, + // so we do not need to check for empty bts. + debug_assert!(!self.bts.is_empty(), "Backtrack stack should not be empty"); + let bt = match self.bts.last_mut() { + Some(bt) => bt, + None => rs_unreachable!("BT stack should never be empty"), + }; + match bt { + BacktrackInsn::Exhausted => return false, + + BacktrackInsn::SetPosition { + ip: saved_ip, + pos: saved_pos, + } => { + *ip = *saved_ip; + *pos = *saved_pos; + self.pop_backtrack(); + return true; + } + BacktrackInsn::SetLoopData { id, data } => { + *self.s.loops.mat(*id as usize) = *data; + self.pop_backtrack(); + } + BacktrackInsn::SetCaptureGroup { id, data } => { + *self.s.groups.mat(*id as usize) = *data; + self.pop_backtrack(); + } + + &mut BacktrackInsn::EnterNonGreedyLoop { + ip: loop_ip, + orig_pos, + data, + } => { + *ip = loop_ip + 1; + *pos = data.entry; + let loop_fields = match &self.re.insns.iat(loop_ip) { + Insn::EnterLoop(loop_fields) => loop_fields, + _ => rs_unreachable!("EnterNonGreedyLoop must point at a loop instruction"), + }; + let loop_data = self.s.loops.mat(loop_fields.loop_id as usize); + // Need to restore the position should we backtrack out of the loop (#131). + *bt = BacktrackInsn::SetLoopData { + id: loop_fields.loop_id, + data: LoopData { + entry: orig_pos, + ..data + }, + }; + *loop_data = data; + MatchAttempter::prepare_to_enter_loop( + &mut self.bts, + *pos, + loop_fields, + loop_data, + ); + return true; + } + + BacktrackInsn::GreedyLoop1Char { + continuation, + min, + max, + } => { + // The match failed at the max location. + debug_assert!( + if Dir::FORWARD { max >= min } else { max <= min }, + "max should be >= min (or <= if tracking backwards)" + ); + // If min is equal to max, there is no more backtracking to be done; + // otherwise move opposite the direction of the cursor. + if *max == *min { + // We have backtracked this loop as far as possible. + self.bts.pop(); + continue; + } + let newmax = if Dir::FORWARD { + input.next_left_pos(*max) + } else { + input.next_right_pos(*max) + }; + if let Some(newmax) = newmax { + *pos = newmax; + *max = newmax; + } else { + rs_unreachable!("Should always be able to advance since min != max") + } + *ip = *continuation; + return true; + } + + BacktrackInsn::NonGreedyLoop1Char { + continuation, + min, + max, + } => { + // The match failed at the min location. + debug_assert!( + if Dir::FORWARD { max >= min } else { max <= min }, + "max should be >= min (or <= if tracking backwards)" + ); + if *max == *min { + // We have backtracked this loop as far as possible. + self.bts.pop(); + continue; + } + // Move in the direction of the cursor. + let newmin = if Dir::FORWARD { + input.next_right_pos(*min) + } else { + input.next_left_pos(*min) + }; + if let Some(newmin) = newmin { + *pos = newmin; + *min = newmin; + } else { + rs_unreachable!("Should always be able to advance since min != max") + } + *ip = *continuation; + return true; + } + } + } + } + + /// Attempt to match at a given IP and position. + fn try_at_pos( + &mut self, + inp: Input, + mut ip: IP, + mut pos: Input::Position, + dir: Dir, + ) -> Option { + debug_assert!( + self.bts.len() == 1, + "Should be only initial exhausted backtrack insn" + ); + // TODO: we are inconsistent about passing Input by reference or value. + let input = &inp; + let re = self.re; + // These are not really loops, they are just labels that we effectively 'goto' + // to. + #[allow(clippy::never_loop)] + 'nextinsn: loop { + 'backtrack: loop { + // Helper macro to either increment ip and go to the next insn, or backtrack. + macro_rules! next_or_bt { + ($e:expr) => { + if $e { + ip += 1; + continue 'nextinsn; + } else { + break 'backtrack; + } + }; + } + + match re.insns.iat(ip) { + &Insn::Char(c) => { + let m = match <::Element as ElementType>::try_from(c) + { + Some(c) => scm::Char { c }.matches(input, dir, &mut pos), + None => false, + }; + next_or_bt!(m); + } + + Insn::CharSet(chars) => { + let m = scm::CharSet { chars }.matches(input, dir, &mut pos); + next_or_bt!(m); + } + + &Insn::ByteSet2(bytes) => { + next_or_bt!(scm::MatchByteArraySet(bytes).matches(input, dir, &mut pos)) + } + &Insn::ByteSet3(bytes) => { + next_or_bt!(scm::MatchByteArraySet(bytes).matches(input, dir, &mut pos)) + } + &Insn::ByteSet4(bytes) => { + next_or_bt!(scm::MatchByteArraySet(bytes).matches(input, dir, &mut pos)) + } + + Insn::ByteSeq1(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq2(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq3(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq4(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq5(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq6(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq7(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq8(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq9(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq10(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq11(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq12(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq13(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq14(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq15(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + Insn::ByteSeq16(v) => { + next_or_bt!(cursor::try_match_lit(input, dir, &mut pos, v)) + } + + &Insn::CharICase(c) => { + let m = match <::Element as indexing::ElementType>::try_from(c) { + Some(c) => scm::CharICase { c }.matches(input, dir, &mut pos), + None => false, + }; + next_or_bt!(m) + } + + Insn::AsciiBracket(bitmap) => next_or_bt!( + scm::MatchByteSet { bytes: bitmap }.matches(input, dir, &mut pos) + ), + + &Insn::Bracket(idx) => { + next_or_bt!( + scm::Bracket { + bc: &self.re.brackets[idx] + } + .matches(input, dir, &mut pos) + ) + } + + Insn::MatchAny => { + next_or_bt!(scm::MatchAny::new().matches(input, dir, &mut pos)) + } + + Insn::MatchAnyExceptLineTerminator => { + next_or_bt!( + scm::MatchAnyExceptLineTerminator::new().matches(input, dir, &mut pos) + ) + } + + &Insn::WordBoundary { invert } => { + // Copy the positions since these destructively move them. + let prev_wordchar = input + .peek_left(pos) + .is_some_and(Input::CharProps::is_word_char); + let curr_wordchar = input + .peek_right(pos) + .is_some_and(Input::CharProps::is_word_char); + let is_boundary = prev_wordchar != curr_wordchar; + next_or_bt!(is_boundary != invert) + } + + &Insn::WordBoundaryUnicodeICase { invert } => { + let prev_wordchar = input + .peek_left(pos) + .is_some_and(Input::CharProps::is_word_char_unicode_icase); + let curr_wordchar = input + .peek_right(pos) + .is_some_and(Input::CharProps::is_word_char_unicode_icase); + let is_boundary = prev_wordchar != curr_wordchar; + next_or_bt!(is_boundary != invert) + } + + Insn::StartOfLine { multiline } => { + let multiline = *multiline; + let matches = match input.peek_left(pos) { + None => true, + Some(c) if multiline && Input::CharProps::is_line_terminator(c) => true, + _ => false, + }; + next_or_bt!(matches) + } + Insn::EndOfLine { multiline } => { + let multiline = *multiline; + let matches = match input.peek_right(pos) { + None => true, // we're at the right of the string + Some(c) if multiline && Input::CharProps::is_line_terminator(c) => true, + _ => false, + }; + next_or_bt!(matches) + } + + &Insn::Jump { target } => { + ip = target as usize; + continue 'nextinsn; + } + + &Insn::BeginCaptureGroup(cg_idx) => { + let cg = self.s.groups.mat(cg_idx as usize); + self.bts.push(BacktrackInsn::SetCaptureGroup { + id: cg_idx, + data: *cg, + }); + if Dir::FORWARD { + cg.start = Some(pos); + debug_assert!( + cg.end.is_none(), + "Should not have already exited capture group we are entering" + ) + } else { + cg.end = Some(pos); + debug_assert!( + cg.start.is_none(), + "Should not have already exited capture group we are entering" + ) + } + next_or_bt!(true) + } + + &Insn::EndCaptureGroup(cg_idx) => { + let cg = self.s.groups.mat(cg_idx as usize); + if Dir::FORWARD { + debug_assert!( + cg.start_matched(), + "Capture group should have been entered" + ); + cg.end = Some(pos); + } else { + debug_assert!( + cg.end_matched(), + "Capture group should have been entered" + ); + cg.start = Some(pos) + } + next_or_bt!(true) + } + + &Insn::ResetCaptureGroup(cg_idx) => { + let cg = self.s.groups.mat(cg_idx as usize); + self.bts.push(BacktrackInsn::SetCaptureGroup { + id: cg_idx, + data: *cg, + }); + cg.reset(); + next_or_bt!(true) + } + + &Insn::BackRef(cg_idx) => { + let cg = self.s.groups.mat(cg_idx as usize); + // Backreferences to a capture group that did not match always succeed (ES5 + // 15.10.2.9). + // Note we may be in the capture group we are examining, e.g. /(abc\1)/. + let matched; + if let Some(orig_range) = cg.as_range() { + if re.flags.icase { + matched = matchers::backref_icase(input, dir, orig_range, &mut pos); + } else { + matched = matchers::backref(input, dir, orig_range, &mut pos); + } + } else { + // This group has not been exited and so the match succeeds (ES6 + // 21.2.2.9). + matched = true; + } + next_or_bt!(matched) + } + + &Insn::Lookahead { + negate, + start_group, + end_group, + continuation, + } => { + if self.run_lookaround::( + input, + ip + 1, + pos, + start_group, + end_group, + negate, + ) { + ip = continuation as IP; + continue 'nextinsn; + } else { + break 'backtrack; + } + } + + &Insn::Lookbehind { + negate, + start_group, + end_group, + continuation, + } => { + if self.run_lookaround::( + input, + ip + 1, + pos, + start_group, + end_group, + negate, + ) { + ip = continuation as IP; + continue 'nextinsn; + } else { + break 'backtrack; + } + } + + &Insn::Alt { secondary } => { + self.push_backtrack(BacktrackInsn::SetPosition { + ip: secondary as IP, + pos, + }); + next_or_bt!(true); + } + + Insn::EnterLoop(fields) => { + // Entering a loop, not re-entering it. + self.s.loops.mat(fields.loop_id as usize).iters = 0; + match self.run_loop(fields, pos, ip) { + Some(next_ip) => { + ip = next_ip; + continue 'nextinsn; + } + None => { + break 'backtrack; + } + } + } + + &Insn::LoopAgain { begin } => { + let act = match re.insns.iat(begin as IP) { + Insn::EnterLoop(fields) => self.run_loop(fields, pos, begin as IP), + _ => rs_unreachable!("EnterLoop should always refer to loop field"), + }; + match act { + Some(next_ip) => { + ip = next_ip; + continue 'nextinsn; + } + None => break 'backtrack, + } + } + + &Insn::Loop1CharBody { + min_iters, + max_iters, + greedy, + } => { + if let Some(next_ip) = self + .run_scm_loop(input, dir, &mut pos, min_iters, max_iters, ip, greedy) + { + ip = next_ip; + continue 'nextinsn; + } else { + break 'backtrack; + } + } + + Insn::Goal => { + // Keep all but the initial give-up bts. + self.bts.truncate(1); + return Some(pos); + } + + Insn::JustFail => { + break 'backtrack; + } + } + } + + // This after the backtrack loop. + // A break 'backtrack will jump here. + if self.try_backtrack(input, &mut ip, &mut pos, dir) { + continue 'nextinsn; + } else { + // We have exhausted the backtracking stack. + debug_assert!(self.bts.len() == 1, "Should have exhausted backtrack stack"); + return None; + } + } + + // This is outside the nextinsn loop. + // It is an error to get here. + // Every instruction should either continue 'nextinsn, or break 'backtrack. + { + #![allow(unreachable_code)] + rs_unreachable!("Should not fall to end of nextinsn loop") + } + } +} + +#[derive(Debug)] +pub struct BacktrackExecutor<'r, Input: InputIndexer> { + input: Input, + matcher: MatchAttempter<'r, Input>, +} + +#[cfg(feature = "utf16")] +impl<'r, Input: InputIndexer> BacktrackExecutor<'r, Input> { + pub(crate) fn new(input: Input, matcher: MatchAttempter<'r, Input>) -> Self { + Self { input, matcher } + } +} + +impl BacktrackExecutor<'_, Input> { + fn successful_match(&mut self, start: Input::Position, end: Input::Position) -> Match { + // We want to simultaneously map our groups to offsets, and clear the groups. + // A for loop is the easiest way to do this while satisfying the borrow checker. + // TODO: avoid allocating so much. + let mut captures = Vec::new(); + captures.reserve_exact(self.matcher.s.groups.len()); + for gd in self.matcher.s.groups.iter_mut() { + captures.push(match gd.as_range() { + Some(r) => Some(Range { + start: self.input.pos_to_offset(r.start), + end: self.input.pos_to_offset(r.end), + }), + None => None, + }); + gd.start = None; + gd.end = None; + } + Match { + range: self.input.pos_to_offset(start)..self.input.pos_to_offset(end), + captures, + group_names: self.matcher.re.group_names.clone(), + } + } + + /// \return the next match for an anchored regex that only matches at the start. + /// This avoids any string searching and only tries matching at the given position. + #[cfg(not(feature = "utf16"))] + fn next_match_anchored( + &mut self, + pos: Input::Position, + next_start: &mut Option, + ) -> Option { + let inp = self.input; + // For anchored regexes, only try matching at the current position + if let Some(end) = self.matcher.try_at_pos(inp, 0, pos, Forward::new()) { + // If we matched the empty string, we have to increment. + if end != pos { + *next_start = Some(end) + } else { + *next_start = inp.next_right_pos(end); + } + Some(self.successful_match(pos, end)) + } else { + // Anchored regex failed to match at this position, no more matches + None + } + } + + /// \return the next match, searching the remaining bytes using the given + /// prefix searcher to quickly find the first potential match location. + fn next_match_with_prefix_search( + &mut self, + mut pos: Input::Position, + next_start: &mut Option, + prefix_search: &PrefixSearch, + ) -> Option { + let inp = self.input; + loop { + // Find the next start location, or None if none. + // Don't try this unless CODE_UNITS_ARE_BYTES - i.e. don't do byte searches + // on UTF-16 or UCS2. + if Input::CODE_UNITS_ARE_BYTES { + pos = inp.find_bytes(pos, prefix_search)?; + } + if let Some(end) = self.matcher.try_at_pos(inp, 0, pos, Forward::new()) { + // If we matched the empty string, we have to increment. + if end != pos { + *next_start = Some(end) + } else { + *next_start = inp.next_right_pos(end); + } + return Some(self.successful_match(pos, end)); + } + // Didn't find it at this position, try the next one. + pos = inp.next_right_pos(pos)?; + } + } +} + +impl exec::MatchProducer for BacktrackExecutor<'_, Input> { + type Position = Input::Position; + + fn initial_position(&self, offset: usize) -> Option { + self.input.try_move_right(self.input.left_end(), offset) + } + + fn next_match( + &mut self, + pos: Input::Position, + next_start: &mut Option, + ) -> Option { + // When UTF-16 support is active prefix search is not used due to the different encoding. + #[cfg(feature = "utf16")] + return self.next_match_with_prefix_search(pos, next_start, &bytesearch::EmptyString {}); + + #[cfg(not(feature = "utf16"))] + match &self.matcher.re.start_pred { + StartPredicate::Arbitrary => { + self.next_match_with_prefix_search(pos, next_start, &bytesearch::EmptyString {}) + } + StartPredicate::StartAnchored => self.next_match_anchored(pos, next_start), + StartPredicate::ByteSet1(bytes) => { + self.next_match_with_prefix_search(pos, next_start, bytes) + } + StartPredicate::ByteSet2(bytes) => { + self.next_match_with_prefix_search(pos, next_start, bytes) + } + StartPredicate::ByteSet3(bytes) => { + self.next_match_with_prefix_search(pos, next_start, bytes) + } + StartPredicate::ByteSeq(bytes) => { + self.next_match_with_prefix_search(pos, next_start, bytes.as_ref()) + } + StartPredicate::ByteBracket(bitmap) => { + self.next_match_with_prefix_search(pos, next_start, bitmap) + } + } + } +} + +impl<'r, 't> exec::Executor<'r, 't> for BacktrackExecutor<'r, Utf8Input<'t>> { + type AsAscii = BacktrackExecutor<'r, AsciiInput<'t>>; + + fn new(re: &'r CompiledRegex, text: &'t str) -> Self { + let input = Utf8Input::new(text, re.flags.unicode); + Self { + input, + matcher: MatchAttempter::new(re, input.left_end()), + } + } +} + +impl<'r, 't> exec::Executor<'r, 't> for BacktrackExecutor<'r, AsciiInput<'t>> { + type AsAscii = BacktrackExecutor<'r, AsciiInput<'t>>; + + fn new(re: &'r CompiledRegex, text: &'t str) -> Self { + let input = AsciiInput::new(text, re.flags.unicode); + Self { + input, + matcher: MatchAttempter::new(re, input.left_end()), + } + } +} diff --git a/third_party/regress/src/codepointset.rs b/third_party/regress/src/codepointset.rs new file mode 100644 index 00000000..55cee562 --- /dev/null +++ b/third_party/regress/src/codepointset.rs @@ -0,0 +1,498 @@ +use crate::util::SliceHelp; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; +use core::cmp::{self, Ordering}; + +pub type CodePoint = u32; + +/// The maximum (inclusive) code point. +pub const CODE_POINT_MAX: CodePoint = 0x10FFFF; + +/// An inclusive range of code points. +/// This is more efficient than InclusiveRange because it does not need to carry +/// around the `Option`. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub struct Interval { + pub(crate) first: CodePoint, + pub(crate) last: CodePoint, +} + +/// A list of sorted, inclusive, non-empty ranges of code points. +impl Interval { + pub(crate) const fn new(first: CodePoint, last: CodePoint) -> Interval { + debug_assert!(first <= last); + Interval { first, last } + } + + #[inline(always)] + pub fn compare(self, cp: u32) -> Ordering { + if self.first > cp { + Ordering::Greater + } else if self.last < cp { + Ordering::Less + } else { + Ordering::Equal + } + } + + /// Return whether self is before rhs. + fn is_before(self, other: Interval) -> bool { + self.last < other.first + } + + /// Return whether self is strictly before rhs. + /// "Strictly" here means there is at least one value after the end of self, + /// and before the start of rhs. Overlapping *or abutting* intervals are + /// not considered strictly before. + fn is_strictly_before(self, rhs: Interval) -> bool { + self.last + 1 < rhs.first + } + + /// Compare two intervals. + /// Overlapping *or abutting* intervals are considered equal. + fn mergecmp(self, rhs: Interval) -> cmp::Ordering { + if self.is_strictly_before(rhs) { + Ordering::Less + } else if rhs.is_strictly_before(self) { + Ordering::Greater + } else { + Ordering::Equal + } + } + + /// Return whether self is mergeable with rhs. + fn mergeable(self, rhs: Interval) -> bool { + self.mergecmp(rhs) == Ordering::Equal + } + + /// Return whether self contains a code point \p cp. + pub fn contains(self, cp: CodePoint) -> bool { + self.first <= cp && cp <= self.last + } + + /// Return whether self overlaps 'other'. + /// Overlaps means that we share at least one code point with 'other'. + pub fn overlaps(self, other: Interval) -> bool { + !self.is_before(other) && !other.is_before(self) + } + + /// Return the interval of codepoints. + pub fn codepoints(self) -> core::ops::Range { + debug_assert!(self.last + 1 > self.last, "Overflow"); + self.first..(self.last + 1) + } + + /// Return the number of contained code points. + pub fn count_codepoints(self) -> usize { + (self.last - self.first + 1) as usize + } +} + +pub(crate) fn interval_contains(interval: &[Interval], cp: u32) -> bool { + interval.binary_search_by(|iv| iv.compare(cp)).is_ok() +} + +/// Merge two intervals, which must be overlapping or abutting. +fn merge_intervals(x: Interval, y: &Interval) -> Interval { + debug_assert!(x.mergeable(*y), "Ranges not mergeable"); + Interval { + first: core::cmp::min(x.first, y.first), + last: core::cmp::max(x.last, y.last), + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CodePointSet { + ivs: Vec, +} + +/// A set of code points stored via as disjoint, non-abutting, sorted intervals. +impl CodePointSet { + pub fn new() -> CodePointSet { + CodePointSet { ivs: Vec::new() } + } + + pub(crate) fn clear(&mut self) { + self.ivs.clear(); + } + + // Return true if the set is empty. + pub(crate) fn is_empty(&self) -> bool { + self.ivs.is_empty() + } + + // Return true if we contain all code points. + pub(crate) fn contains_all_codepoints(&self) -> bool { + self.ivs.len() == 1 && self.ivs[0] == Interval::new(0, CODE_POINT_MAX) + } + + pub(crate) fn contains(&self, cp: u32) -> bool { + interval_contains(&self.ivs, cp) + } + + #[inline] + fn assert_is_well_formed(&self) { + if cfg!(debug_assertions) { + for iv in &self.ivs { + debug_assert!(iv.last <= CODE_POINT_MAX); + debug_assert!(iv.first <= iv.last); + } + for w in self.ivs.windows(2) { + debug_assert!(w[0].is_strictly_before(w[1])); + } + } + } + + /// Construct from sorted, disjoint intervals. Note these are not allowed to + /// even abut. + pub fn from_sorted_disjoint_intervals(ivs: Vec) -> CodePointSet { + let res = CodePointSet { ivs }; + res.assert_is_well_formed(); + res + } + + /// Add an interval of code points to the set. + pub fn add(&mut self, new_iv: Interval) { + // Find the mergeable subarray, that is, the range of intervals that intersect + // or abut new_iv. + let mergeable = self.ivs.equal_range_by(|iv| iv.mergecmp(new_iv)); + + // Check our work. + if cfg!(debug_assertions) { + debug_assert!(new_iv.first <= new_iv.last); + for (idx, iv) in self.ivs.iter().enumerate() { + if idx < mergeable.start { + debug_assert!(iv.is_strictly_before(new_iv)); + } else if idx >= mergeable.end { + debug_assert!(new_iv.is_strictly_before(*iv)); + } else { + debug_assert!(iv.mergeable(new_iv) && new_iv.mergeable(*iv)); + } + } + } + + // Merge all the overlapping intervals (possibly none), and then replace the + // range. Tests show that drain(), which modifies the vector, is not effectively + // optimized, so try to avoid it in the cases of a new entry or replacing an existing + // entry. + match mergeable.end - mergeable.start { + 0 => { + // New entry. + self.ivs.insert(mergeable.start, new_iv); + } + 1 => { + // Replace a single entry. + let entry = &mut self.ivs[mergeable.start]; + *entry = Interval { + first: cmp::min(entry.first, new_iv.first), + last: cmp::max(entry.last, new_iv.last), + }; + } + _ => { + // Replace range of entries. + let merged_iv: Interval = self.ivs[mergeable.clone()] + .iter() + .fold(new_iv, merge_intervals); + self.ivs[mergeable.start] = merged_iv; + self.ivs.drain(mergeable.start + 1..mergeable.end); + } + } + self.assert_is_well_formed(); + } + + /// Add a single code point to the set. + #[inline] + pub fn add_one(&mut self, cp: CodePoint) { + self.add(Interval { + first: cp, + last: cp, + }) + } + + /// Add another code point set. + pub fn add_set(&mut self, mut rhs: CodePointSet) { + // Prefer to add to the set with more intervals. + if self.ivs.len() < rhs.ivs.len() { + core::mem::swap(self, &mut rhs); + } + for iv in rhs.intervals() { + self.add(*iv) + } + } + + /// \return the intervals + pub fn intervals(&self) -> &[Interval] { + self.ivs.as_slice() + } + + /// \return the number of intervals that would be produced by inverting. + pub fn inverted_interval_count(&self) -> usize { + let mut result = 0; + let mut start: CodePoint = 0; + for iv in &self.ivs { + if start < iv.first { + result += 1; + } + start = iv.last + 1; + } + if start <= CODE_POINT_MAX { + result += 1; + } + result + } + + /// \return an inverted set: a set containing every code point NOT in the + /// receiver. + pub fn inverted(&self) -> CodePointSet { + // The intervals we collect. + let mut inverted_ivs = Vec::new(); + + // The first code point *not* in the previous interval. + let mut start: CodePoint = 0; + for iv in &self.ivs { + if start < iv.first { + inverted_ivs.push(Interval { + first: start, + last: iv.first - 1, + }) + } + start = iv.last + 1; + } + if start <= CODE_POINT_MAX { + inverted_ivs.push(Interval { + first: start, + last: CODE_POINT_MAX, + }) + } + CodePointSet::from_sorted_disjoint_intervals(inverted_ivs) + } + + /// Remove the the given intervals from the set. + /// + /// Invariants: The intervals must be sorted and disjoint. + pub(crate) fn remove(&mut self, intervals: &[Interval]) { + let mut result = Vec::new(); + let mut remove_iter = intervals.iter().peekable(); + let mut current_remove = remove_iter.next(); + + for iv in &mut self.ivs { + while let Some(remove_iv) = current_remove { + if remove_iv.last < iv.first { + current_remove = remove_iter.next(); + } else if remove_iv.first > iv.last { + result.push(*iv); + break; + } else { + if remove_iv.first > iv.first { + result.push(Interval { + first: iv.first, + last: remove_iv.first - 1, + }); + } + if remove_iv.last < iv.last { + iv.first = remove_iv.last + 1; + current_remove = remove_iter.next(); + } else { + break; + } + } + } + if current_remove.is_none() { + result.push(*iv); + } + } + + self.ivs = result; + } + + /// Intersect the set with the given intervals. + pub(crate) fn intersect(&mut self, intervals: &[Interval]) { + let mut new_ivs = Vec::new(); + for iv in intervals { + for self_iv in self.intervals() { + if iv.overlaps(*self_iv) { + new_ivs.push(Interval { + first: cmp::max(iv.first, self_iv.first), + last: cmp::min(iv.last, self_iv.last), + }); + } + } + } + self.ivs = new_ivs; + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn iv(first: u32, last: u32) -> Interval { + Interval { first, last } + } + + #[test] + fn test_is_before() { + let a = iv(0, 9); + let b = iv(10, 19); + assert!(a.is_before(b)); + assert!(!b.is_before(a)); + } + + #[test] + fn test_is_strictly_before() { + let a = iv(0, 9); + let b = iv(10, 19); + let c = iv(11, 19); + assert!(!a.is_strictly_before(b)); + assert!(a.is_strictly_before(c)); + assert!(!b.is_strictly_before(a)); + assert!(!b.is_strictly_before(c)); + } + + #[test] + fn test_mergecmp() { + let a = iv(0, 9); + let b = iv(10, 19); + let c = iv(9, 18); + assert_eq!(a.mergecmp(b), Ordering::Equal); + assert_eq!(b.mergecmp(a), Ordering::Equal); + assert_eq!(a.mergecmp(c), Ordering::Equal); + assert_eq!(c.mergecmp(a), Ordering::Equal); + + let d = iv(11, 19); + assert_eq!(a.mergecmp(d), Ordering::Less); + assert_eq!(d.mergecmp(a), Ordering::Greater); + assert_eq!(b.mergecmp(d), Ordering::Equal); + assert_eq!(d.mergecmp(b), Ordering::Equal); + assert_eq!(c.mergecmp(d), Ordering::Equal); + assert_eq!(d.mergecmp(c), Ordering::Equal); + + let e = iv(100, 109); + assert_eq!(a.mergecmp(e), Ordering::Less); + assert_eq!(e.mergecmp(a), Ordering::Greater); + } + + #[test] + fn test_mergeable() { + let a = iv(0, 9); + let b = iv(9, 19); + assert!(a.mergeable(a)); + assert!(a.mergeable(b)); + assert!(b.mergeable(b)); + } + + #[test] + fn test_contains() { + let a = iv(0, 9); + assert!(a.contains(0)); + assert!(a.contains(9)); + assert!(!a.contains(10)); + } + + #[test] + fn test_overlaps() { + let a = iv(0, 9); + let b = iv(5, 14); + let c = iv(10, 19); + assert!(a.overlaps(b)); + assert!(!a.overlaps(c)); + } + + #[test] + fn test_codepoints() { + let a = iv(0, 9); + assert_eq!(a.codepoints(), 0..10); + } + + #[test] + fn test_count_codepoints() { + assert_eq!(iv(0, 9).count_codepoints(), 10); + assert_eq!(iv(0, 0).count_codepoints(), 1); + assert_eq!( + iv(0, CODE_POINT_MAX).count_codepoints(), + (CODE_POINT_MAX + 1) as usize + ); + } + + #[test] + fn test_add() { + let mut set = CodePointSet::new(); + set.add(iv(10, 20)); + set.add(iv(30, 40)); + set.add(iv(15, 35)); + assert_eq!(set.intervals(), &[iv(10, 40)]); + } + + #[test] + fn test_add_one() { + let mut set = CodePointSet::new(); + set.add_one(10); + set.add_one(20); + set.add_one(15); + assert_eq!(set.intervals(), &[iv(10, 10), iv(15, 15), iv(20, 20)]); + } + + #[test] + fn test_add_set() { + let mut set1 = CodePointSet::new(); + set1.add(iv(10, 20)); + set1.add(iv(30, 40)); + let mut set2 = CodePointSet::new(); + set2.add(iv(15, 25)); + set2.add(iv(35, 45)); + set1.add_set(set2); + assert_eq!(set1.intervals(), &[iv(10, 25), iv(30, 45)]); + } + + #[test] + fn test_inverted() { + let mut set = CodePointSet::new(); + set.add(iv(10, 20)); + set.add(iv(30, 40)); + let inverted_set = set.inverted(); + assert_eq!( + inverted_set.intervals(), + &[iv(0, 9), iv(21, 29), iv(41, CODE_POINT_MAX)] + ); + let set_again = inverted_set.inverted(); + assert_eq!(set_again.intervals(), set.intervals()); + + assert_eq!( + set.inverted_interval_count(), + inverted_set.intervals().len() + ); + assert_eq!( + inverted_set.inverted_interval_count(), + set.intervals().len() + ); + } + + #[test] + fn test_adds_torture() { + let mut set = CodePointSet::new(); + set.add(iv(1, 3)); + assert_eq!(&set.intervals(), &[iv(1, 3)]); + set.add(iv(0, 0)); + assert_eq!(&set.intervals(), &[iv(0, 3)]); + set.add(iv(3, 5)); + assert_eq!(&set.intervals(), &[iv(0, 5)]); + set.add(iv(6, 10)); + assert_eq!(&set.intervals(), &[iv(0, 10)]); + set.add(iv(15, 15)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(15, 15)]); + set.add(iv(12, 14)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(12, 15)]); + set.add(iv(16, 20)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(12, 20)]); + set.add(iv(21, 22)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(12, 22)]); + set.add(iv(23, 23)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(12, 23)]); + set.add(iv(100, 200)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(12, 23), iv(100, 200)]); + set.add(iv(201, 250)); + assert_eq!(&set.intervals(), &[iv(0, 10), iv(12, 23), iv(100, 250)]); + set.add(iv(0, 0x10ffff)); + assert_eq!(&set.intervals(), &[iv(0, 0x10ffff)]); + } +} diff --git a/third_party/regress/src/cursor.rs b/third_party/regress/src/cursor.rs new file mode 100644 index 00000000..87c3a9b5 --- /dev/null +++ b/third_party/regress/src/cursor.rs @@ -0,0 +1,77 @@ +use crate::indexing::InputIndexer; + +#[derive(Debug, Copy, Clone)] +pub struct Forward; + +#[derive(Debug, Copy, Clone)] +pub struct Backward; + +pub trait Direction: core::fmt::Debug + Copy + Clone { + const FORWARD: bool; + fn new() -> Self; +} + +impl Direction for Forward { + const FORWARD: bool = true; + #[inline(always)] + fn new() -> Self { + Forward {} + } +} + +impl Direction for Backward { + const FORWARD: bool = false; + #[inline(always)] + fn new() -> Self { + Backward {} + } +} + +/// \return whether we match some literal bytes. +/// If so, update the position. If not, the position is unspecified. +#[inline(always)] +pub fn try_match_lit( + input: &Input, + dir: Dir, + pos: &mut Input::Position, + bytes: &[u8; N], +) -> bool { + input.match_bytes(dir, pos, bytes) +} + +/// \return the next character, updating the position. +#[inline(always)] +pub fn next( + input: &Input, + _dir: Dir, + pos: &mut Input::Position, +) -> Option { + if Dir::FORWARD { + input.next_right(pos) + } else { + input.next_left(pos) + } +} + +/// \return the next *byte*, or None if at the end, updating the position. +/// Note this may break UTF8 sequences. +#[inline(always)] +pub fn next_byte( + input: &Input, + _dir: Dir, + pos: &mut Input::Position, +) -> Option { + assert!( + Input::CODE_UNITS_ARE_BYTES, + "Not implemented for non-byte input" + ); + let res; + if Dir::FORWARD { + res = input.peek_byte_right(*pos); + *pos += if res.is_some() { 1 } else { 0 }; + } else { + res = input.peek_byte_left(*pos); + *pos -= if res.is_some() { 1 } else { 0 }; + } + res +} diff --git a/third_party/regress/src/emit.rs b/third_party/regress/src/emit.rs new file mode 100644 index 00000000..376e2035 --- /dev/null +++ b/third_party/regress/src/emit.rs @@ -0,0 +1,410 @@ +//! Regex compiler back-end: transforms IR into a CompiledRegex + +use crate::bytesearch::{AsciiBitmap, ByteArraySet}; +use crate::insn::{CompiledRegex, Insn, LoopFields, MAX_BYTE_SEQ_LENGTH, MAX_CHAR_SET_LENGTH}; +use crate::ir; +use crate::ir::Node; +use crate::startpredicate; +use crate::types::{BracketContents, CaptureGroupID, LoopID}; +use crate::unicode; +use core::convert::TryInto; +#[cfg(not(feature = "std"))] +use {alloc::vec::Vec, hashbrown::HashMap}; + +/// \return an anchor instruction for a given IR anchor. +fn make_anchor(anchor_type: ir::AnchorType, multiline: bool) -> Insn { + match anchor_type { + ir::AnchorType::StartOfLine => Insn::StartOfLine { multiline }, + ir::AnchorType::EndOfLine => Insn::EndOfLine { multiline }, + } +} + +/// Weirdly placed optimization. +/// If the given bracket can be represented as ASCII contents, return the +/// bitmap. Otherwise nothing. +fn bracket_as_ascii(bc: &BracketContents) -> Option { + let mut result = AsciiBitmap::default(); + // We just assume that inverted brackets contain non-ASCII characters. + if bc.invert { + return None; + } + for r in bc.cps.intervals() { + debug_assert!(r.first <= r.last); + if r.last >= 128 { + return None; + } + for bit in r.first..=r.last { + result.set(bit as u8) + } + } + Some(result) +} + +/// Type which wraps up the context needed to emit a CompiledRegex. +struct Emitter { + result: CompiledRegex, + + // Number of loops seen so far. + next_loop_id: LoopID, + + // List of group names, in order, with empties for unnamed groups. + group_names: Vec>, + + // Whether the current node is within a lookbehind. + in_lookbehind: bool, +} + +impl Emitter { + /// Emit a ByteSet instruction. + /// We awkwardly optimize it like so. + fn emit_byte_set_insn(&mut self, bytes: &[u8]) { + let insn = match bytes.len() { + 0 => Insn::JustFail, + 1 => Insn::ByteSeq1(bytes.try_into().unwrap()), + 2 => Insn::ByteSet2(ByteArraySet(bytes.try_into().unwrap())), + 3 => Insn::ByteSet3(ByteArraySet(bytes.try_into().unwrap())), + 4 => Insn::ByteSet4(ByteArraySet(bytes.try_into().unwrap())), + _ => panic!("Byte set is too long"), + }; + self.emit_insn(insn); + } + + // Emit a nonempty byte sequence instruction. The sequence must be at most MAX_BYTE_SEQ_LENGTH bytes. + fn emit_byte_sequence_insn(&mut self, seq: &[u8]) { + const { + assert!( + MAX_BYTE_SEQ_LENGTH == 16, + "Need to update our emitting logic" + ); + }; + let insn = match seq.len() { + 1 => Insn::ByteSeq1(seq.try_into().unwrap()), + 2 => Insn::ByteSeq2(seq.try_into().unwrap()), + 3 => Insn::ByteSeq3(seq.try_into().unwrap()), + 4 => Insn::ByteSeq4(seq.try_into().unwrap()), + 5 => Insn::ByteSeq5(seq.try_into().unwrap()), + 6 => Insn::ByteSeq6(seq.try_into().unwrap()), + 7 => Insn::ByteSeq7(seq.try_into().unwrap()), + 8 => Insn::ByteSeq8(seq.try_into().unwrap()), + 9 => Insn::ByteSeq9(seq.try_into().unwrap()), + 10 => Insn::ByteSeq10(seq.try_into().unwrap()), + 11 => Insn::ByteSeq11(seq.try_into().unwrap()), + 12 => Insn::ByteSeq12(seq.try_into().unwrap()), + 13 => Insn::ByteSeq13(seq.try_into().unwrap()), + 14 => Insn::ByteSeq14(seq.try_into().unwrap()), + 15 => Insn::ByteSeq15(seq.try_into().unwrap()), + 16 => Insn::ByteSeq16(seq.try_into().unwrap()), + _ => panic!("Unexpected chunk size"), + }; + self.emit_insn(insn); + } + + /// Emit an instruction. + /// Return the "instruction" as an index. + fn emit_insn(&mut self, insn: Insn) { + self.result.insns.push(insn); + } + + /// Get an instruction at a given index. + fn get_insn(&mut self, idx: u32) -> &mut Insn { + &mut self.result.insns[idx as usize] + } + + /// \return the offset of the next instruction emitted. + fn next_offset(&self) -> u32 { + self.result.insns.len() as u32 + } + + fn emit_insn_offset(&mut self, insn: Insn) -> u32 { + let ret = self.next_offset(); + self.emit_insn(insn); + ret + } + + /// Emit instructions corresponding to a given node. + fn emit_node(&mut self, node: &Node) { + enum Emitter<'a> { + Node(&'a Node), + NodeLoopFinish { + loop_instruction_index: u32, + }, + NodeLookaroundAssertionFinish { + lookaround_instruction_index: u32, + prev_in_lookbehind: bool, + }, + NodeAltMiddle { + alt_instruction_index: u32, + right_node: &'a Node, + }, + NodeAltFinish { + alt_instruction_index: u32, + jump_instruction_index: u32, + right_branch_index: u32, + }, + EndCaptureGroup { + group: CaptureGroupID, + }, + } + + let mut stack = vec![Emitter::Node(node)]; + + while let Some(inst) = stack.pop() { + match inst { + Emitter::NodeLoopFinish { + loop_instruction_index, + } => { + self.emit_insn(Insn::LoopAgain { + begin: loop_instruction_index, + }); + // Fix up our loop exit. + let exit = self.next_offset(); + match self.get_insn(loop_instruction_index) { + Insn::EnterLoop(fields) => fields.exit = exit, + _ => panic!("Should be an EnterLoop instruction"), + } + } + Emitter::NodeLookaroundAssertionFinish { + lookaround_instruction_index, + prev_in_lookbehind, + } => { + self.emit_insn(Insn::Goal); + // Fix up the continuation. + let next_insn = self.next_offset(); + match self.get_insn(lookaround_instruction_index) { + Insn::Lookbehind { continuation, .. } => *continuation = next_insn, + Insn::Lookahead { continuation, .. } => *continuation = next_insn, + _ => panic!("Should be a Lookaround instruction"), + } + self.in_lookbehind = prev_in_lookbehind; + } + Emitter::NodeAltMiddle { + alt_instruction_index, + right_node, + } => { + let jump_insn = self.emit_insn_offset(Insn::Jump { target: 0 }); + let right_branch = self.next_offset(); + stack.push(Emitter::NodeAltFinish { + alt_instruction_index, + jump_instruction_index: jump_insn, + right_branch_index: right_branch, + }); + stack.push(Emitter::Node(right_node)); + } + Emitter::NodeAltFinish { + alt_instruction_index, + jump_instruction_index, + right_branch_index, + } => { + let exit = self.next_offset(); + // Fix up our jump targets. + match self.get_insn(alt_instruction_index) { + Insn::Alt { secondary } => *secondary = right_branch_index, + _ => panic!("Should be an Alt instruction"), + } + match self.get_insn(jump_instruction_index) { + Insn::Jump { target } => *target = exit, + _ => panic!("Should be a Jump instruction"), + } + } + Emitter::EndCaptureGroup { group } => self.emit_insn(Insn::EndCaptureGroup(group)), + Emitter::Node(node) => match node { + Node::Empty => {} + Node::Goal => self.emit_insn(Insn::Goal), + Node::Char { c, icase } => { + let c = *c; + if !*icase { + self.emit_insn(Insn::Char(c)) + } else { + core::debug_assert!( + unicode::fold_code_point(c, self.result.flags.unicode) == c, + "Char {:x} should be folded", + c + ); + self.emit_insn(Insn::CharICase(c)) + } + } + Node::Cat(children) => { + for nn in children.iter().rev() { + stack.push(Emitter::Node(nn)); + } + } + Node::Alt(left, right) => { + // Alternation is followed by the primary branch and has a jump to secondary + // branch. After primary branch, jump to the continuation. + let alt_insn = self.emit_insn_offset(Insn::Alt { secondary: 0 }); + stack.push(Emitter::NodeAltMiddle { + alt_instruction_index: alt_insn, + right_node: right, + }); + stack.push(Emitter::Node(left)); + } + Node::Bracket(contents) => { + if let Some(ascii_contents) = bracket_as_ascii(contents) { + self.emit_insn(Insn::AsciiBracket(ascii_contents)) + } else { + let idx = self.result.brackets.len(); + self.result.brackets.push(contents.clone()); + self.emit_insn(Insn::Bracket(idx)) + } + } + Node::MatchAny => self.emit_insn(Insn::MatchAny), + Node::MatchAnyExceptLineTerminator => { + self.emit_insn(Insn::MatchAnyExceptLineTerminator) + } + Node::Anchor { + anchor_type, + multiline, + } => self.emit_insn(make_anchor(*anchor_type, *multiline)), + Node::Loop { + loopee, + quant, + enclosed_groups, + } => { + let loop_id = self.next_loop_id; + self.next_loop_id += 1; + let loop_insn = self.emit_insn_offset(Insn::EnterLoop(LoopFields { + loop_id, + min_iters: quant.min, + // If the loop is unbounded, just emit usize::MAX, + // as we cannot match more characters than that. + max_iters: quant.max.unwrap_or(usize::MAX), + greedy: quant.greedy, + exit: 0, + })); + self.result.loops += 1; + // Emit a sequence of ResetCaptureGroup for any contained groups. + for gid in enclosed_groups.start..enclosed_groups.end { + self.emit_insn(Insn::ResetCaptureGroup(gid)) + } + stack.push(Emitter::NodeLoopFinish { + loop_instruction_index: loop_insn, + }); + stack.push(Emitter::Node(loopee)); + } + Node::Loop1CharBody { loopee, quant } => { + self.emit_insn(Insn::Loop1CharBody { + min_iters: quant.min, + max_iters: quant.max.unwrap_or(usize::MAX), + greedy: quant.greedy, + }); + stack.push(Emitter::Node(loopee)); + } + Node::CaptureGroup { id, contents, name } => { + let group = *id; + self.result.groups += 1; + self.group_names.push(name.as_deref().unwrap_or("").into()); + self.emit_insn(Insn::BeginCaptureGroup(group)); + stack.push(Emitter::EndCaptureGroup { group }); + stack.push(Emitter::Node(contents)); + } + Node::LookaroundAssertion { + negate, + backwards, + start_group, + end_group, + contents, + } => { + let lookaround = if *backwards { + self.emit_insn_offset(Insn::Lookbehind { + negate: *negate, + start_group: *start_group, + end_group: *end_group, + continuation: 0, + }) + } else { + self.emit_insn_offset(Insn::Lookahead { + negate: *negate, + start_group: *start_group, + end_group: *end_group, + continuation: 0, + }) + }; + let prev_in_lookbehind = self.in_lookbehind; + self.in_lookbehind = *backwards; + stack.push(Emitter::NodeLookaroundAssertionFinish { + lookaround_instruction_index: lookaround, + prev_in_lookbehind, + }); + stack.push(Emitter::Node(contents)); + } + &Node::WordBoundary { invert } => { + if self.result.flags.unicode && self.result.flags.icase { + self.emit_insn(Insn::WordBoundaryUnicodeICase { invert }) + } else { + self.emit_insn(Insn::WordBoundary { invert }) + } + } + &Node::BackRef(group) => { + debug_assert!(group >= 1, "Group should not be zero"); + // -1 because \1 matches the first capture group, which has index 0. + self.emit_insn(Insn::BackRef(group - 1)) + } + + Node::ByteSet(bytes) => self.emit_byte_set_insn(bytes), + + Node::CharSet(chars) => { + debug_assert!(chars.len() <= MAX_CHAR_SET_LENGTH); + if chars.is_empty() { + self.emit_insn(Insn::JustFail); + } else { + let mut arr = [chars[0]; MAX_CHAR_SET_LENGTH]; + arr[..chars.len()].copy_from_slice(chars.as_slice()); + self.emit_insn(Insn::CharSet(arr)) + } + } + + Node::ByteSequence(bytes) => { + // In a lookbehind, instruction order is reversed, but ByteSequence contents are not, + // to take advantage of optimized memcmp. For example, `(?<=abcd)` may be emitted + // as "d", "c", "b", "a" char matches (traversing input from right to left), or + // optimized to a single forwards ByteSequence("abcd"), which matches left-to-right. + // Therefore if we split a byte sequence into multiple instructions, + // we need to emit them in reverse order iff in a lookbehind. + let chunks = bytes.as_slice().chunks(MAX_BYTE_SEQ_LENGTH); + if self.in_lookbehind { + for chunk in chunks.rev() { + self.emit_byte_sequence_insn(chunk); + } + } else { + for chunk in chunks { + self.emit_byte_sequence_insn(chunk); + } + } + } + }, + } + } + } +} + +/// Compile the given IR to a CompiledRegex. +pub fn emit(n: &ir::Regex) -> CompiledRegex { + let mut emitter = Emitter { + next_loop_id: 0, + group_names: Vec::new(), + in_lookbehind: false, + result: CompiledRegex { + insns: Vec::new(), + brackets: Vec::new(), + loops: 0, + groups: 0, + group_names: Box::new([]), + flags: n.flags, + start_pred: startpredicate::predicate_for_re(n), + }, + }; + emitter.emit_node(&n.node); + let mut result = emitter.result; + // Populate group names, unless all are empty. + debug_assert!( + result.group_names.is_empty(), + "Group names should not be set" + ); + if emitter.group_names.iter().any(|s| !s.is_empty()) { + result.group_names = emitter.group_names.into_boxed_slice(); + } + debug_assert!( + result.group_names.is_empty() || result.group_names.len() == result.groups as usize + ); + result +} diff --git a/third_party/regress/src/exec.rs b/third_party/regress/src/exec.rs new file mode 100644 index 00000000..1181ed3f --- /dev/null +++ b/third_party/regress/src/exec.rs @@ -0,0 +1,56 @@ +//! Execution engine bits. + +use crate::api::Match; +use crate::insn::CompiledRegex; +use crate::position::PositionType; + +/// A trait for finding the next match in a regex. +/// This is broken out from Executor to avoid needing to thread lifetimes +/// around. +pub trait MatchProducer: core::fmt::Debug { + /// The position type of our indexer. + type Position: PositionType; + + /// \return an initial position for the given start offset. + fn initial_position(&self, offset: usize) -> Option; + + /// Attempt to match at the given location. + /// \return either the Match and the position to start looking for the next + /// match, or None on failure. + fn next_match( + &mut self, + pos: Self::Position, + next_start: &mut Option, + ) -> Option; +} + +/// A trait for executing a regex. +pub trait Executor<'r, 't>: MatchProducer { + /// The ASCII variant. + type AsAscii: Executor<'r, 't>; + + /// Construct a new Executor. + fn new(re: &'r CompiledRegex, text: &'t str) -> Self; +} + +/// A struct which enables iteration over matches. +#[derive(Debug)] +pub struct Matches { + mp: Producer, + position: Option, +} + +impl Matches { + pub fn new(mp: Producer, start: usize) -> Self { + let position = mp.initial_position(start); + Matches { mp, position } + } +} + +impl Iterator for Matches { + type Item = Match; + fn next(&mut self) -> Option { + let pos = self.position?; + self.mp.next_match(pos, &mut self.position) + } +} diff --git a/third_party/regress/src/indexing.rs b/third_party/regress/src/indexing.rs new file mode 100644 index 00000000..44a80d52 --- /dev/null +++ b/third_party/regress/src/indexing.rs @@ -0,0 +1,1292 @@ +use crate::bytesearch; +use crate::cursor::Direction; +use crate::matchers::{self, CharProperties}; +#[cfg(feature = "utf16")] +use crate::position::IndexPosition; +use crate::position::{DefPosition, PositionType}; +use crate::util::{is_utf8_continuation, utf8_w2, utf8_w3, utf8_w4}; +use core::convert::TryInto; +use core::ops::Range; +use core::{ops, str}; + +// A type which may be an Element. +pub trait ElementType: + core::fmt::Debug + + Copy + + Clone + + core::cmp::Eq + + core::cmp::Ord + + core::convert::Into + + core::convert::TryFrom +{ + /// Return another ElementType as self. + #[inline(always)] + fn try_from(v: Elem) -> Option { + // Annoying there is no char->u8 conversion. + let vv: u32 = v.into(); + vv.try_into().ok() + } + + #[inline(always)] + fn as_u32(self) -> u32 { + self.into() + } +} + +impl ElementType for char {} + +impl ElementType for u8 {} + +impl ElementType for u32 {} + +// A helper type that holds a string and allows indexing into it. +pub trait InputIndexer: core::fmt::Debug + Copy + Clone +where + Self::CharProps: matchers::CharProperties, +{ + /// The char type, typically u8 or char. + type Element: ElementType; + + /// The CharProperties to use for the given element. + type CharProps: matchers::CharProperties; + + /// A type which references a position in the input string. + type Position: PositionType; + + /// Whether we have bytes as code units. This can optimize some operations. + /// This is true for ASCII and UTF8, but not for UCS2 or UTF16. + const CODE_UNITS_ARE_BYTES: bool; + + /// \return whether we are using unicode for case-folding. + fn unicode(&self) -> bool; + + /// Case-fold an element. + fn fold(&self, c: Self::Element) -> Self::Element { + Self::CharProps::fold(c, self.unicode()) + } + + /// Return whether these two elements fold to the same value. + fn fold_equals(&self, c1: Self::Element, c2: Self::Element) -> bool { + c1 == c2 || self.fold(c1) == self.fold(c2) + } + + /// \return a sub-input. Note that positions in the original may no longer be valid in the sub-input. + fn subinput(&self, range: ops::Range) -> Self; + + /// \return the char to the right (starting at) \p idx, or None if we are at + /// the end. Advance the position by the amount. + fn next_right(&self, pos: &mut Self::Position) -> Option; + + /// \return the char to the left (ending just before) \p idx, or None if we are at + /// the end. Retreat the position by the amount. + fn next_left(&self, pos: &mut Self::Position) -> Option; + + // Like next_right, but does not decode the element. + fn next_right_pos(&self, pos: Self::Position) -> Option; + + // Like next_left, but does not decode the element. + fn next_left_pos(&self, pos: Self::Position) -> Option; + + /// \return the byte to the right (starting at) \p idx, or None if we are at + /// the end. This panics if CODE_UNITS_ARE_BYTES is false. + fn peek_byte_right(&self, pos: Self::Position) -> Option; + + /// \return the byte to the left (ending just before) \p idx, or None if we + /// are at the start. This panics if CODE_UNITS_ARE_BYTES is false. + fn peek_byte_left(&self, pos: Self::Position) -> Option; + + /// \return a position at the left end of this input. + fn left_end(&self) -> Self::Position; + + /// \return a position at the right end of this input. + fn right_end(&self) -> Self::Position; + + /// Move a position right by a certain amount. + /// \return the new position, or None if it would exceed the length. + fn try_move_right(&self, pos: Self::Position, amt: usize) -> Option; + + /// Move a position left by a certain amount. + /// \return the new position, or None if it would underflow 0. + fn try_move_left(&self, pos: Self::Position, amt: usize) -> Option; + + /// Convert a position to an offset. + fn pos_to_offset(&self, pos: Self::Position) -> usize; + + /// Apply a literal byte matcher, finding a literal byte sequence in a string. + /// \return the new position, or None on failure. + fn find_bytes( + &self, + pos: Self::Position, + search: &Search, + ) -> Option; + + /// Peek at the char to the right of a position, without changing that position. + #[inline(always)] + fn peek_right(&self, mut pos: Self::Position) -> Option { + self.next_right(&mut pos) + } + + /// Peek at the char to the left of a position, without changing that position. + #[inline(always)] + fn peek_left(&self, mut pos: Self::Position) -> Option { + self.next_left(&mut pos) + } + + /// Check if the subrange `range` is byte-for-byte equal to a range of the same length from the current position `pos`. + /// If `dir` is FORWARD, then the range is checked starting at `pos` and ending at `pos + range.len()`. + /// If `dir` is BACKWARD, then the range is checked starting at `pos - range.len()` and ending at `pos`. + fn subrange_eq( + &self, + dir: Dir, + pos: &mut Self::Position, + range: Range, + ) -> bool; + + /// Return whether we match some literal bytes. + /// If so, update the position. If not, the position is unspecified. + fn match_bytes( + &self, + dir: Dir, + pos: &mut Self::Position, + bytes: &[u8; N], + ) -> bool; +} + +/// \return the length of a UTF8 sequence starting with this byte. +#[inline(always)] +const fn utf8_seq_len(b: u8) -> usize { + if b < 128 { + 1 + } else { + match b & 0xF0 { + 0xE0 => 3, + 0xF0 => 4, + _ => 2, + } + } +} + +/// \return whether a byte represents the start of a utf8 sequence (aka a +/// char boundary). +#[inline(always)] +fn is_seq_start(b: u8) -> bool { + // Taken from is_char_boundary. + // "This is bit magic equivalent to: b < 128 || b >= 192" + (b as i8) >= -0x40 +} + +#[derive(Debug, Copy, Clone)] +pub struct Utf8Input<'a> { + input: &'a str, + unicode: bool, +} + +impl<'a> Utf8Input<'a> { + #[inline(always)] + fn contents(&self) -> &[u8] { + self.input.as_bytes() + } + + #[inline(always)] + fn bytelength(&self) -> usize { + self.input.len() + } + + #[inline(always)] + fn slice( + &self, + start: ::Position, + end: ::Position, + ) -> &[u8] { + self.debug_assert_valid_pos(start); + self.debug_assert_valid_pos(end); + debug_assert!(end >= start, "Slice start after end"); + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let res = &self.contents()[core::ops::Range { + start: self.pos_to_offset(start), + end: self.pos_to_offset(end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let res = unsafe { core::slice::from_raw_parts(start.ptr(), end - start) }; + + debug_assert!(res.len() <= self.bytelength() && res.len() == end - start); + res + } + + #[inline(always)] + pub fn new(s: &'a str, unicode: bool) -> Self { + // The big idea of RefPosition is enforced here. + ::Position::check_size(); + + Self { input: s, unicode } + } + + /// \return a byte at a given position. + /// This asserts that we are not at the right end. + #[inline(always)] + fn getb(&self, pos: ::Position) -> u8 { + debug_assert!(self.left_end() <= pos && pos < self.right_end()); + if cfg!(feature = "prohibit-unsafe") { + self.contents()[self.pos_to_offset(pos)] + } else { + unsafe { *self.contents().get_unchecked(self.pos_to_offset(pos)) } + } + } + + /// \return a slice as a str. + #[inline(always)] + fn str_slice(&self, range: ops::Range<::Position>) -> &'a str { + self.debug_assert_boundary(range.start); + self.debug_assert_boundary(range.end); + if cfg!(feature = "prohibit-unsafe") { + &self.input[core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }] + } else { + unsafe { + self.input.get_unchecked(core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }) + } + } + } + + /// Assert that a position is valid, i.e. between our left and right ends. + #[inline(always)] + fn debug_assert_valid_pos(&self, pos: ::Position) { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + } + + /// Assert that a position is a valid UTF8 character boundary. + #[inline(always)] + fn debug_assert_boundary(&self, pos: ::Position) { + self.debug_assert_valid_pos(pos); + debug_assert!(pos == self.right_end() || is_seq_start(self.getb(pos))); + } +} + +impl<'a> InputIndexer for Utf8Input<'a> { + type Position = DefPosition<'a>; + type Element = char; + type CharProps = matchers::UTF8CharProperties; + const CODE_UNITS_ARE_BYTES: bool = true; + + #[inline(always)] + fn unicode(&self) -> bool { + self.unicode + } + + #[inline(always)] + fn subinput(&self, range: ops::Range) -> Self { + Self::new(self.str_slice(range), self.unicode) + } + + #[inline(always)] + fn next_right(&self, pos: &mut Self::Position) -> Option { + self.debug_assert_boundary(*pos); + if *pos == self.right_end() { + return None; + } + + let b0 = self.getb(*pos); + if b0 < 128 { + *pos += 1; + return Some(b0 as Self::Element); + } + + // Multibyte case. + let len = utf8_seq_len(b0); + let codepoint = match len { + 2 => utf8_w2(b0, self.getb(*pos + 1)), + 3 => utf8_w3(b0, self.getb(*pos + 1), self.getb(*pos + 2)), + 4 => utf8_w4( + b0, + self.getb(*pos + 1), + self.getb(*pos + 2), + self.getb(*pos + 3), + ), + _ => rs_unreachable!("Invalid utf8 sequence length"), + }; + *pos += len; + if let Some(c) = core::char::from_u32(codepoint) { + Some(c) + } else { + rs_unreachable!("Should have decoded a valid char from utf8 sequence"); + } + } + + #[inline(always)] + fn next_right_pos(&self, mut pos: Self::Position) -> Option { + self.debug_assert_boundary(pos); + if pos == self.right_end() { + return None; + } + + let b0 = self.getb(pos); + if b0 < 128 { + return Some(pos + 1); + } + + // Multibyte case. + pos += utf8_seq_len(b0); + self.debug_assert_boundary(pos); + Some(pos) + } + + #[inline(always)] + fn next_left(&self, pos: &mut Self::Position) -> Option { + self.debug_assert_boundary(*pos); + if *pos == self.left_end() { + return None; + } + + let z = self.getb(*pos - 1); + if z < 128 { + *pos -= 1; + return Some(z as Self::Element); + } + + // Multibyte case. + // bytes are w x y z, with 'pos' pointing after z. + let codepoint; + let y = self.getb(*pos - 2); + if !is_utf8_continuation(y) { + codepoint = utf8_w2(y, z); + *pos -= 2; + } else { + let x = self.getb(*pos - 3); + if !is_utf8_continuation(x) { + codepoint = utf8_w3(x, y, z); + *pos -= 3; + } else { + let w = self.getb(*pos - 4); + codepoint = utf8_w4(w, x, y, z); + *pos -= 4; + } + } + self.debug_assert_boundary(*pos); + if let Some(c) = core::char::from_u32(codepoint) { + Some(c) + } else { + rs_unreachable!("Should have decoded a valid char from utf8 sequence"); + } + } + + #[inline(always)] + fn next_left_pos(&self, mut pos: Self::Position) -> Option { + self.debug_assert_boundary(pos); + if pos == self.left_end() { + return None; + } + + let z = self.getb(pos - 1); + if z < 128 { + pos -= 1; + self.debug_assert_valid_pos(pos); + return Some(pos); + } + + if !is_utf8_continuation(self.getb(pos - 2)) { + pos -= 2; + } else if !is_utf8_continuation(self.getb(pos - 3)) { + pos -= 3; + } else { + debug_assert!(!is_utf8_continuation(self.getb(pos - 4))); + pos -= 4; + } + self.debug_assert_valid_pos(pos); + Some(pos) + } + + #[inline(always)] + fn peek_byte_right(&self, pos: Self::Position) -> Option { + self.debug_assert_valid_pos(pos); + if pos == self.right_end() { + None + } else { + Some(self.getb(pos)) + } + } + + #[inline(always)] + fn peek_byte_left(&self, pos: Self::Position) -> Option { + self.debug_assert_valid_pos(pos); + if pos == self.left_end() { + None + } else { + Some(self.getb(pos - 1)) + } + } + + #[inline(always)] + fn try_move_right(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if self.right_end() - pos < amt { + None + } else { + pos += amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn try_move_left(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if pos - self.left_end() < amt { + None + } else { + pos -= amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[cfg(feature = "index-positions")] + #[inline(always)] + fn left_end(&self) -> Self::Position { + Self::Position::new(0) + } + + #[cfg(feature = "index-positions")] + #[inline(always)] + fn right_end(&self) -> Self::Position { + Self::Position::new(self.bytelength()) + } + + #[cfg(not(feature = "index-positions"))] + #[inline(always)] + fn left_end(&self) -> Self::Position { + Self::Position::new(self.contents().as_ptr()) + } + + #[cfg(not(feature = "index-positions"))] + #[inline(always)] + fn right_end(&self) -> Self::Position { + self.left_end() + self.bytelength() + } + + #[inline(always)] + fn pos_to_offset(&self, pos: Self::Position) -> usize { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + pos - self.left_end() + } + + #[inline(always)] + fn find_bytes( + &self, + pos: Self::Position, + search: &Search, + ) -> Option { + let rem = self.slice(pos, self.right_end()); + let idx = search.find_in(rem)?; + Some(pos + idx) + } + + fn subrange_eq( + &self, + _dir: Dir, + pos: &mut Self::Position, + range: Range, + ) -> bool { + let len = range.end - range.start; + let (start, end) = if Dir::FORWARD { + if let Some(end) = self.try_move_right(*pos, len) { + let start = *pos; + *pos = end; + (start, end) + } else { + return false; + } + } else if let Some(start) = self.try_move_left(*pos, len) { + let end = *pos; + *pos = start; + (start, end) + } else { + return false; + }; + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let new_range = &self.contents()[core::ops::Range { + start: self.pos_to_offset(start), + end: self.pos_to_offset(end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let new_range = unsafe { core::slice::from_raw_parts(start.ptr(), end - start) }; + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let old_range = &self.contents()[core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let old_range = + unsafe { core::slice::from_raw_parts(range.start.ptr(), range.end - range.start) }; + + new_range == old_range + } + + fn match_bytes( + &self, + _dir: Dir, + pos: &mut Self::Position, + bytes: &[u8; N], + ) -> bool { + let len = N; + let (start, end) = if Dir::FORWARD { + if let Some(end) = self.try_move_right(*pos, len) { + let start = *pos; + *pos = end; + (start, end) + } else { + return false; + } + } else if let Some(start) = self.try_move_left(*pos, len) { + let end = *pos; + *pos = start; + (start, end) + } else { + return false; + }; + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let new_range = &self.contents()[core::ops::Range { + start: self.pos_to_offset(start), + end: self.pos_to_offset(end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let new_range = unsafe { core::slice::from_raw_parts(start.ptr(), end - start) }; + + bytes == new_range + } +} + +#[derive(Debug, Copy, Clone)] +pub struct AsciiInput<'a> { + input: &'a [u8], + unicode: bool, +} + +impl<'a> AsciiInput<'a> { + #[inline(always)] + fn contents(&self) -> &[u8] { + self.input + } + + #[inline(always)] + fn bytelength(&self) -> usize { + self.input.len() + } + + #[inline(always)] + fn slice( + &self, + start: ::Position, + end: ::Position, + ) -> &[u8] { + self.debug_assert_valid_pos(start); + self.debug_assert_valid_pos(end); + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let res = &self.contents()[core::ops::Range { + start: self.pos_to_offset(start), + end: self.pos_to_offset(end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let res = unsafe { core::slice::from_raw_parts(start.ptr(), end - start) }; + + debug_assert!(res.len() <= self.bytelength() && res.len() == end - start); + res + } + + pub fn new(s: &'a str, unicode: bool) -> Self { + // The big idea of RefPosition is enforced here. + ::Position::check_size(); + + Self { + input: s.as_bytes(), + unicode, + } + } + + /// \return a byte at a given position. + /// This asserts that we are not at the right end. + #[inline(always)] + fn getb(&self, pos: ::Position) -> u8 { + debug_assert!(self.left_end() <= pos && pos < self.right_end()); + if cfg!(feature = "prohibit-unsafe") { + self.contents()[self.pos_to_offset(pos)] + } else { + unsafe { *self.contents().get_unchecked(self.pos_to_offset(pos)) } + } + } + + #[inline(always)] + fn debug_assert_valid_pos(&self, pos: ::Position) -> &Self { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + self + } +} + +impl<'a> InputIndexer for AsciiInput<'a> { + type Position = DefPosition<'a>; + type Element = u8; + type CharProps = matchers::ASCIICharProperties; + const CODE_UNITS_ARE_BYTES: bool = true; + + #[inline(always)] + fn unicode(&self) -> bool { + self.unicode + } + + #[inline(always)] + fn subinput(&self, range: ops::Range) -> AsciiInput<'a> { + self.debug_assert_valid_pos(range.start); + self.debug_assert_valid_pos(range.end); + debug_assert!(range.end >= range.start); + AsciiInput { + input: &self.input[core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }], + unicode: self.unicode(), + } + } + + #[inline(always)] + fn next_right(&self, pos: &mut Self::Position) -> Option { + self.debug_assert_valid_pos(*pos); + if *pos == self.right_end() { + None + } else { + let c = self.getb(*pos); + *pos += 1; + self.debug_assert_valid_pos(*pos); + Some(c) + } + } + + #[inline(always)] + fn next_left(&self, pos: &mut Self::Position) -> Option { + self.debug_assert_valid_pos(*pos); + if *pos == self.left_end() { + None + } else { + *pos -= 1; + self.debug_assert_valid_pos(*pos); + let c = self.getb(*pos); + Some(c) + } + } + + #[inline(always)] + fn next_right_pos(&self, pos: Self::Position) -> Option { + self.try_move_right(pos, 1) + } + + #[inline(always)] + fn next_left_pos(&self, pos: Self::Position) -> Option { + self.try_move_left(pos, 1) + } + + #[inline(always)] + fn peek_byte_right(&self, mut pos: Self::Position) -> Option { + self.next_right(&mut pos) + } + + #[inline(always)] + fn peek_byte_left(&self, mut pos: Self::Position) -> Option { + self.next_left(&mut pos) + } + + #[cfg(feature = "index-positions")] + #[inline(always)] + fn left_end(&self) -> Self::Position { + Self::Position::new(0) + } + + #[cfg(feature = "index-positions")] + #[inline(always)] + fn right_end(&self) -> Self::Position { + Self::Position::new(self.bytelength()) + } + + #[cfg(not(feature = "index-positions"))] + #[inline(always)] + fn left_end(&self) -> Self::Position { + Self::Position::new(self.contents().as_ptr()) + } + + #[cfg(not(feature = "index-positions"))] + #[inline(always)] + fn right_end(&self) -> Self::Position { + self.left_end() + self.bytelength() + } + + #[inline(always)] + fn pos_to_offset(&self, pos: Self::Position) -> usize { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + pos - self.left_end() + } + + fn try_move_right(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if self.right_end() - pos < amt { + None + } else { + pos += amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn try_move_left(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if pos - self.left_end() < amt { + None + } else { + pos -= amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn find_bytes( + &self, + pos: Self::Position, + search: &Search, + ) -> Option { + let rem = self.slice(pos, self.right_end()); + let idx = search.find_in(rem)?; + Some(pos + idx) + } + + fn subrange_eq( + &self, + _dir: Dir, + pos: &mut Self::Position, + range: Range, + ) -> bool { + let len = range.end - range.start; + let (start, end) = if Dir::FORWARD { + if let Some(end) = self.try_move_right(*pos, len) { + let start = *pos; + *pos = end; + (start, end) + } else { + return false; + } + } else if let Some(start) = self.try_move_left(*pos, len) { + let end = *pos; + *pos = start; + (start, end) + } else { + return false; + }; + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let new_range = &self.contents()[core::ops::Range { + start: self.pos_to_offset(start), + end: self.pos_to_offset(end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let new_range = unsafe { core::slice::from_raw_parts(start.ptr(), end - start) }; + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let old_range = &self.contents()[core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let old_range = + unsafe { core::slice::from_raw_parts(range.start.ptr(), range.end - range.start) }; + + new_range == old_range + } + + fn match_bytes( + &self, + _dir: Dir, + pos: &mut Self::Position, + bytes: &[u8; N], + ) -> bool { + let len = N; + let (start, end) = if Dir::FORWARD { + if let Some(end) = self.try_move_right(*pos, len) { + let start = *pos; + *pos = end; + (start, end) + } else { + return false; + } + } else if let Some(start) = self.try_move_left(*pos, len) { + let end = *pos; + *pos = start; + (start, end) + } else { + return false; + }; + + #[cfg(any(feature = "index-positions", feature = "prohibit-unsafe"))] + let new_range = &self.contents()[core::ops::Range { + start: self.pos_to_offset(start), + end: self.pos_to_offset(end), + }]; + + #[cfg(all(not(feature = "index-positions"), not(feature = "prohibit-unsafe")))] + let new_range = unsafe { core::slice::from_raw_parts(start.ptr(), end - start) }; + + bytes == new_range + } +} + +#[cfg(feature = "utf16")] +#[derive(Debug, Copy, Clone)] +pub struct Utf16Input<'a> { + input: &'a [u16], + unicode: bool, +} + +#[cfg(feature = "utf16")] +impl<'a> Utf16Input<'a> { + pub fn new(s: &'a [u16], unicode: bool) -> Self { + Self { input: s, unicode } + } + + #[inline(always)] + fn debug_assert_valid_pos(&self, pos: ::Position) -> &Self { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + self + } + + const SURROGATE_HIGH_START: u16 = 0xD800; + const SURROGATE_HIGH_END: u16 = 0xDBFF; + const SURROGATE_LOW_START: u16 = 0xDC00; + const SURROGATE_LOW_END: u16 = 0xDFFF; + + #[inline(always)] + fn is_high_surrogate(b: u16) -> bool { + b >= Self::SURROGATE_HIGH_START && b <= Self::SURROGATE_HIGH_END + } + + #[inline(always)] + fn is_low_surrogate(b: u16) -> bool { + b >= Self::SURROGATE_LOW_START && b <= Self::SURROGATE_LOW_END + } + + #[inline(always)] + fn code_point_from_surrogates(high: u16, low: u16) -> u32 { + (((high & 0x3ff) as u32) << 10 | (low & 0x3ff) as u32) + 0x1_0000 + } +} + +#[cfg(feature = "utf16")] +impl<'a> InputIndexer for Utf16Input<'a> { + type Position = IndexPosition<'a>; + type Element = u32; + type CharProps = matchers::Utf16CharProperties; + const CODE_UNITS_ARE_BYTES: bool = false; + + #[inline(always)] + fn unicode(&self) -> bool { + self.unicode + } + + #[inline(always)] + fn subinput(&self, range: ops::Range) -> Utf16Input<'a> { + self.debug_assert_valid_pos(range.start); + self.debug_assert_valid_pos(range.end); + debug_assert!(range.end >= range.start); + Utf16Input { + input: &self.input[core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }], + unicode: self.unicode(), + } + } + + #[inline(always)] + fn next_right(&self, pos: &mut Self::Position) -> Option { + let u1 = self.input.get(self.pos_to_offset(*pos)).copied()?; + *pos += 1; + + // If the code unit is not a high surrogate, it is not the start of a surrogate pair. + if !Self::is_high_surrogate(u1) { + return Some(u1.into()); + } + + let Some(u2) = self.input.get(self.pos_to_offset(*pos)).copied() else { + return Some(u1.into()); + }; + + // If the code unit is not a low surrogate, it is not a surrogate pair. + if !Self::is_low_surrogate(u2) { + return Some(u1.into()); + } + + *pos += 1; + Some(Self::code_point_from_surrogates(u1, u2)) + } + + #[inline(always)] + fn next_left(&self, pos: &mut Self::Position) -> Option { + let left_end = self.left_end(); + if *pos == left_end { + return None; + } + + let u2 = self.input.get(self.pos_to_offset(*pos - 1)).copied()?; + *pos -= 1; + + // If the code unit is not a low surrogate, it is not the end of a surrogate pair. + if *pos == left_end || !Self::is_low_surrogate(u2) { + return Some(u2.into()); + } + + let Some(u1) = self.input.get(self.pos_to_offset(*pos - 1)).copied() else { + return Some(u2.into()); + }; + + // If the code unit is not a high surrogate, it is not a surrogate pair. + if !Self::is_high_surrogate(u1) { + return Some(u2.into()); + } + + *pos -= 1; + Some(Self::code_point_from_surrogates(u1, u2)) + } + + #[inline(always)] + fn next_right_pos(&self, mut pos: Self::Position) -> Option { + let u1 = self.input.get(self.pos_to_offset(pos)).copied()?; + pos += 1; + + // If the code unit is not a high surrogate, it is not the start of a surrogate pair. + if !Self::is_high_surrogate(u1) { + return Some(pos); + } + + let Some(u2) = self.input.get(self.pos_to_offset(pos)).copied() else { + return Some(pos); + }; + + // If the code unit is not a low surrogate, it is not a surrogate pair. + if !Self::is_low_surrogate(u2) { + return Some(pos); + } + + pos += 1; + + Some(pos) + } + + #[inline(always)] + fn next_left_pos(&self, mut pos: Self::Position) -> Option { + let left_end = self.left_end(); + if pos == left_end { + return None; + } + + let u2 = self.input.get(self.pos_to_offset(pos - 1)).copied()?; + pos -= 1; + + // If the code unit is not a low surrogate, it is not the end of a surrogate pair. + if pos == left_end || !Self::is_low_surrogate(u2) { + return Some(pos); + } + + let Some(u1) = self.input.get(self.pos_to_offset(pos - 1)).copied() else { + return Some(pos); + }; + + // If the code unit is not a high surrogate, it is not a surrogate pair. + if !Self::is_high_surrogate(u1) { + return Some(pos); + } + + pos -= 1; + Some(pos) + } + + #[inline(always)] + fn peek_byte_right(&self, _pos: Self::Position) -> Option { + panic!("Should never be inspecting bytes for utf16"); + } + + #[inline(always)] + fn peek_byte_left(&self, _pos: Self::Position) -> Option { + panic!("Should never be inspecting bytes for utf16"); + } + + #[inline(always)] + fn left_end(&self) -> Self::Position { + Self::Position::new(0) + } + + #[inline(always)] + fn right_end(&self) -> Self::Position { + Self::Position::new(self.input.len()) + } + + #[inline(always)] + fn pos_to_offset(&self, pos: Self::Position) -> usize { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + pos - self.left_end() + } + + fn try_move_right(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if self.right_end() - pos < amt { + None + } else { + pos += amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn try_move_left(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if pos - self.left_end() < amt { + None + } else { + pos -= amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn find_bytes( + &self, + _pos: Self::Position, + _search: &Search, + ) -> Option { + panic!("Should never be finding bytes for utf16"); + } + + fn subrange_eq( + &self, + _dir: Dir, + pos: &mut Self::Position, + range: Range, + ) -> bool { + let len = range.end - range.start; + let (start, end) = if Dir::FORWARD { + if let Some(end) = self.try_move_right(*pos, len) { + let start = *pos; + *pos = end; + (start, end) + } else { + return false; + } + } else if let Some(start) = self.try_move_left(*pos, len) { + let end = *pos; + *pos = start; + (start, end) + } else { + return false; + }; + + let new_range = &self.input[self.pos_to_offset(start)..self.pos_to_offset(end)]; + let old_range = &self.input[self.pos_to_offset(range.start)..self.pos_to_offset(range.end)]; + + new_range == old_range + } + + fn match_bytes( + &self, + _dir: Dir, + _pos: &mut Self::Position, + _bytes: &[u8; N], + ) -> bool { + panic!("Should never be matching bytes for utf16"); + } +} + +#[cfg(feature = "utf16")] +#[derive(Debug, Copy, Clone)] +pub struct Ucs2Input<'a> { + input: &'a [u16], + unicode: bool, +} + +#[cfg(feature = "utf16")] +impl<'a> Ucs2Input<'a> { + pub fn new(s: &'a [u16], unicode: bool) -> Self { + Self { input: s, unicode } + } + + #[inline(always)] + fn debug_assert_valid_pos(&self, pos: ::Position) -> &Self { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + self + } +} + +#[cfg(feature = "utf16")] +impl<'a> InputIndexer for Ucs2Input<'a> { + type Position = IndexPosition<'a>; + type Element = u32; + type CharProps = matchers::Utf16CharProperties; + const CODE_UNITS_ARE_BYTES: bool = false; + + #[inline(always)] + fn unicode(&self) -> bool { + self.unicode + } + + #[inline(always)] + fn subinput(&self, range: ops::Range) -> Ucs2Input<'a> { + self.debug_assert_valid_pos(range.start); + self.debug_assert_valid_pos(range.end); + debug_assert!(range.end >= range.start); + Ucs2Input { + input: &self.input[core::ops::Range { + start: self.pos_to_offset(range.start), + end: self.pos_to_offset(range.end), + }], + unicode: self.unicode(), + } + } + + #[inline(always)] + fn next_right(&self, pos: &mut Self::Position) -> Option { + let u1 = self.input.get(self.pos_to_offset(*pos)).copied()?; + *pos += 1; + + Some(u1.into()) + } + + #[inline(always)] + fn next_left(&self, pos: &mut Self::Position) -> Option { + if *pos == self.left_end() { + return None; + } + + let u2 = self.input.get(self.pos_to_offset(*pos - 1)).copied()?; + *pos -= 1; + + Some(u2.into()) + } + + #[inline(always)] + fn next_right_pos(&self, pos: Self::Position) -> Option { + self.try_move_right(pos, 1) + } + + #[inline(always)] + fn next_left_pos(&self, pos: Self::Position) -> Option { + self.try_move_left(pos, 1) + } + + #[inline(always)] + fn peek_byte_right(&self, _pos: Self::Position) -> Option { + panic!("Should never be inspecting bytes for ucs2"); + } + + #[inline(always)] + fn peek_byte_left(&self, _pos: Self::Position) -> Option { + panic!("Should never be inspecting bytes for ucs2"); + } + + #[inline(always)] + fn left_end(&self) -> Self::Position { + Self::Position::new(0) + } + + #[inline(always)] + fn right_end(&self) -> Self::Position { + Self::Position::new(self.input.len()) + } + + #[inline(always)] + fn pos_to_offset(&self, pos: Self::Position) -> usize { + debug_assert!(self.left_end() <= pos && pos <= self.right_end()); + pos - self.left_end() + } + + fn try_move_right(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if self.right_end() - pos < amt { + None + } else { + pos += amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn try_move_left(&self, mut pos: Self::Position, amt: usize) -> Option { + self.debug_assert_valid_pos(pos); + if pos - self.left_end() < amt { + None + } else { + pos -= amt; + self.debug_assert_valid_pos(pos); + Some(pos) + } + } + + #[inline(always)] + fn find_bytes( + &self, + _pos: Self::Position, + _search: &Search, + ) -> Option { + panic!("Should never be finding bytes for ucs2"); + } + + fn subrange_eq( + &self, + _dir: Dir, + pos: &mut Self::Position, + range: Range, + ) -> bool { + let len = range.end - range.start; + let (start, end) = if Dir::FORWARD { + if let Some(end) = self.try_move_right(*pos, len) { + let start = *pos; + *pos = end; + (start, end) + } else { + return false; + } + } else if let Some(start) = self.try_move_left(*pos, len) { + let end = *pos; + *pos = start; + (start, end) + } else { + return false; + }; + + let new_range = &self.input[self.pos_to_offset(start)..self.pos_to_offset(end)]; + let old_range = &self.input[self.pos_to_offset(range.start)..self.pos_to_offset(range.end)]; + + new_range == old_range + } + + fn match_bytes( + &self, + _dir: Dir, + _pos: &mut Self::Position, + _bytes: &[u8; N], + ) -> bool { + panic!("Should never be matching bytes for ucs2"); + } +} diff --git a/third_party/regress/src/insn.rs b/third_party/regress/src/insn.rs new file mode 100644 index 00000000..3e802083 --- /dev/null +++ b/third_party/regress/src/insn.rs @@ -0,0 +1,220 @@ +//! Bytecode instructions for a compiled regex + +#[cfg(not(feature = "std"))] +use { + alloc::{string::String, vec::Vec}, + hashbrown::HashMap, +}; + +use crate::api; +use crate::bytesearch::{AsciiBitmap, ByteArraySet, ByteBitmap}; +use crate::types::{BracketContents, CaptureGroupID, LoopID}; +extern crate memchr; +use memchr::memmem; + +type JumpTarget = u32; + +/// The maximum size of a byte sequence instruction. +pub const MAX_BYTE_SEQ_LENGTH: usize = 16; + +/// The maximum size of an array-type-byteset instruction. +pub const MAX_BYTE_SET_LENGTH: usize = 4; + +/// The maximum size of an array-type-charset instruction. +/// This also happens to be the maximum number of characters in case-insensitive +/// equivalence classes. +pub const MAX_CHAR_SET_LENGTH: usize = 4; + +#[derive(Debug, Clone)] +pub struct LoopFields { + pub loop_id: LoopID, + pub min_iters: usize, + pub max_iters: usize, + pub greedy: bool, + pub exit: JumpTarget, +} + +#[derive(Debug, Clone)] +/// The list of bytecode instructions. +pub enum Insn { + /// The match was successful. + Goal, + + /// Match a single char. + Char(u32), + + /// Match a single char, case-insensitive. + CharICase(u32), + + /// Match the start of a line (if multiline); emitted by '^' + StartOfLine { + multiline: bool, + }, + + /// Match the end of a line; emitted by '$' + EndOfLine { + multiline: bool, + }, + + /// Match any character except a line terminator; emitted by '.' only when + /// the dot_all flag is set to true. + MatchAny, + + /// Match any character except a line terminator; emitted by '.' + MatchAnyExceptLineTerminator, + + /// Enter a loop from "outside". + EnterLoop(LoopFields), + + /// Re-enter a loop. + LoopAgain { + begin: JumpTarget, + }, + + /// The next instruction is a "1Char" instruction which always matches one + /// character. Attempt to match it [min, max] times. + Loop1CharBody { + min_iters: usize, + max_iters: usize, + greedy: bool, + }, + + /// Set the IP to a new value. + Jump { + target: JumpTarget, + }, + + /// The next instruction is the primary branch. + /// If it fails to match, jump to secondary. + Alt { + secondary: JumpTarget, + }, + + /// Enter a capture group. + BeginCaptureGroup(CaptureGroupID), + + /// Exit a capture group. + EndCaptureGroup(CaptureGroupID), + + /// Clear a capture group. + ResetCaptureGroup(CaptureGroupID), + + /// Perform a backreference match. + BackRef(u32), + + /// Match the next character against the bracket contents, stored at the given index in the CompiledRegex. + Bracket(usize), + + /// A simple bitmap bracket for ASCII. + /// It contains a bitmap of the range [0, 127]. + AsciiBracket(AsciiBitmap), + + /// Perform a lookahead assertion. + Lookahead { + negate: bool, + start_group: CaptureGroupID, + end_group: CaptureGroupID, + continuation: JumpTarget, + }, + + /// Perform a lookbehind assertion. + Lookbehind { + negate: bool, + start_group: CaptureGroupID, + end_group: CaptureGroupID, + continuation: JumpTarget, + }, + + /// \w or \W word boundaries. + WordBoundary { + invert: bool, + }, + + /// \w or \W word boundaries in Unicode case-insensitive mode. + /// This considers characters that fold to ASCII word chars as word chars, + /// per ES9 21.2.2.6.1. + WordBoundaryUnicodeICase { + invert: bool, + }, + + /// Match any of the contained chars + /// There is no length field; characters are simply duplicated as necessary. + CharSet([u32; MAX_CHAR_SET_LENGTH]), + + /// Match the next byte against some possibilities. + ByteSet2(ByteArraySet<[u8; 2]>), + ByteSet3(ByteArraySet<[u8; 3]>), + ByteSet4(ByteArraySet<[u8; 4]>), + + /// Match a sequence of literal bytes. + ByteSeq1([u8; 1]), + ByteSeq2([u8; 2]), + ByteSeq3([u8; 3]), + ByteSeq4([u8; 4]), + ByteSeq5([u8; 5]), + ByteSeq6([u8; 6]), + ByteSeq7([u8; 7]), + ByteSeq8([u8; 8]), + ByteSeq9([u8; 9]), + ByteSeq10([u8; 10]), + ByteSeq11([u8; 11]), + ByteSeq12([u8; 12]), + ByteSeq13([u8; 13]), + ByteSeq14([u8; 14]), + ByteSeq15([u8; 15]), + ByteSeq16([u8; 16]), + + /// An instruction that always fails, which may be produced in weird cases + /// like an inverted bracket which matches everything. + JustFail, +} + +/// The peeled prefix start predicate. +/// This is a fast way of locating the first potential match. +#[derive(Debug, Clone)] +pub enum StartPredicate { + /// May match an arbitrary sequence. + Arbitrary, + + /// Look for the first instance of any of the given bytes. + ByteSet1([u8; 1]), + ByteSet2([u8; 2]), + ByteSet3([u8; 3]), + + /// Look for a byte sequence. + ByteSeq(Box>), + + /// Look for a byte which matches the bitmap. + ByteBracket(ByteBitmap), + + /// The regex is anchored to the start of the line/string. + /// This avoids string searching entirely and only tries matching at the beginning. + StartAnchored, +} + +#[derive(Debug, Clone)] +pub struct CompiledRegex { + // Sequence of instructions. + pub insns: Vec, + + // The bracket contents, indexed by the value of the `Bracket` instruction. + pub brackets: Vec, + + // Predicate to rapidly find the first potential match. + pub start_pred: StartPredicate, + + // Number of loops, used to populate loop data. + pub loops: u32, + + // Number of capture groups, used to populate capture group data. + pub groups: u32, + + // A list of capture group names. This is either: + // - Empty, if there were no named capture groups. + // - A list of names with length `groups`, corresponding to the capture + // group names in order. Groups without names have an empty string. + pub group_names: Box<[Box]>, + + // Flags controlling matching. + pub flags: api::Flags, +} diff --git a/third_party/regress/src/ir.rs b/third_party/regress/src/ir.rs new file mode 100644 index 00000000..55d5cfa7 --- /dev/null +++ b/third_party/regress/src/ir.rs @@ -0,0 +1,590 @@ +//! Intermediate representation for a regex + +use crate::api; +use crate::types::{BracketContents, CaptureGroupID, CaptureGroupName}; +#[cfg(not(feature = "std"))] +use alloc::{boxed::Box, string::ToString, vec::Vec}; +use core::fmt; + +#[derive(Debug, Copy, Clone)] +pub enum AnchorType { + StartOfLine, // ^ + EndOfLine, // $ +} + +/// A Quantifier. +#[derive(Debug, Copy, Clone)] +pub struct Quantifier { + /// Minimum number of iterations of the loop, inclusive. + pub min: usize, + + /// Maximum number of iterations of the loop, inclusive; + /// or None if unbounded. + pub max: Option, + + /// Whether the loop is greedy. + pub greedy: bool, +} + +/// The node types of our IR. +#[derive(Debug)] +pub enum Node { + /// Matches the empty string. + Empty, + + /// Reaching this node terminates the match successfully. + Goal, + + /// Match a literal character. + /// If icase is true, then `c` MUST be already folded. + Char { c: u32, icase: bool }, + + /// Match a literal sequence of bytes. + ByteSequence(Vec), + + /// Match any of a set of *bytes*. + /// This may not exceed length MAX_BYTE_SET_LENGTH. + ByteSet(Vec), + + /// Match any of a set of *chars*, case-insensitive. + /// This may not exceed length MAX_CHAR_SET_LENGTH. + CharSet(Vec), + + /// Match the catenation of multiple nodes. + Cat(Vec), + + /// Match an alternation like a|b. + Alt(Box, Box), + + /// Match anything including newlines. + MatchAny, + + /// Match anything except a newline. + MatchAnyExceptLineTerminator, + + /// Match an anchor like ^ or $. The `multiline` flag controls whether the + /// anchor should treat line terminators as boundaries. + Anchor { + anchor_type: AnchorType, + multiline: bool, + }, + + /// Word boundary (\b or \B). + WordBoundary { invert: bool }, + + /// A capturing group. + /// If the name is set, it is guaranteed nonempty. + /// Note that multiple capture groups may share the same name in different alternations. + CaptureGroup { + id: CaptureGroupID, + contents: Box, + name: Option, + }, + + /// A backreference. + /// Indices are 1-based. That is, it matches JS syntax: \1 is the first capture group, + /// not everything. + /// A backreference that logically may match multiple capture groups (through shared names) + /// are emitted through alternations of backreferences. + BackRef(u32), + + /// A bracket. + Bracket(BracketContents), + + /// A lookaround assertions like (?:) or (?!). + LookaroundAssertion { + negate: bool, + backwards: bool, + start_group: CaptureGroupID, + end_group: CaptureGroupID, + contents: Box, + }, + + /// A loop like /.*/ or /x{3, 5}?/ + Loop { + loopee: Box, + quant: Quantifier, + enclosed_groups: core::ops::Range, + }, + + /// A loop whose body matches exactly one character. + /// Enclosed capture groups are forbidden here. + Loop1CharBody { + loopee: Box, + quant: Quantifier, + }, +} + +pub type NodeList = Vec; + +impl Node { + /// Helper to return an "always fails" node. + pub fn make_always_fails() -> Node { + Node::CharSet(Vec::new()) + } + + /// Reverse the children of \p self if in a lookbehind. + /// Used as a parameter to walk_mut. + pub fn reverse_cats(&mut self, w: &mut Walk) { + match self { + Node::Cat(nodes) if w.in_lookbehind => nodes.reverse(), + Node::ByteSequence(..) => panic!("Should not be reversing literal bytes"), + _ => {} + } + } + + /// \return whether this is an Empty node. + pub fn is_empty(&self) -> bool { + matches!(self, Node::Empty) + } + + /// \return whether this is a Cat node. + pub fn is_cat(&self) -> bool { + matches!(self, Node::Cat(..)) + } + + /// \return whether this node is known to match exactly one char. + /// This is best-effort: a false return is always safe. + pub fn matches_exactly_one_char(&self) -> bool { + match self { + Node::Char { .. } => true, + Node::CharSet(contents) => !contents.is_empty(), + Node::Bracket(contents) => !contents.is_empty(), + Node::MatchAny => true, + Node::MatchAnyExceptLineTerminator => true, + _ => false, + } + } + + /// \return true if this node will always fail to match. + /// Note this is different than matching the empty string. + /// For example, an empty bracket /[]/ tries to match one char + /// from an empty set. + pub fn match_always_fails(&self) -> bool { + match self { + Node::ByteSet(bytes) => bytes.is_empty(), + Node::CharSet(contents) => contents.is_empty(), + Node::Bracket(contents) => contents.is_empty(), + _ => false, + } + } + + /// Duplicate a node, perhaps assigning new loop IDs. Note we must never + /// copy a capture group. + /// + /// Returns None if the depth is too high. + pub fn try_duplicate(&self, mut depth: usize) -> Option { + if depth > 100 { + return None; + } + depth += 1; + Some(match self { + Node::Empty => Node::Empty, + Node::Goal => Node::Goal, + &Node::Char { c, icase } => Node::Char { c, icase }, + Node::ByteSequence(bytes) => Node::ByteSequence(bytes.clone()), + Node::ByteSet(bytes) => Node::ByteSet(bytes.clone()), + Node::CharSet(chars) => Node::CharSet(chars.clone()), + Node::Cat(nodes) => { + let mut new_nodes = Vec::with_capacity(nodes.len()); + for n in nodes { + new_nodes.push(n.try_duplicate(depth)?); + } + Node::Cat(new_nodes) + } + Node::Alt(left, right) => Node::Alt( + Box::new(left.try_duplicate(depth)?), + Box::new(right.try_duplicate(depth)?), + ), + Node::MatchAny => Node::MatchAny, + Node::MatchAnyExceptLineTerminator => Node::MatchAnyExceptLineTerminator, + &Node::Anchor { + anchor_type, + multiline, + } => Node::Anchor { + anchor_type, + multiline, + }, + + Node::Loop { + loopee, + quant, + enclosed_groups, + } => { + assert!( + enclosed_groups.start >= enclosed_groups.end, + "Cannot duplicate a loop with enclosed groups" + ); + Node::Loop { + loopee: Box::new(loopee.as_ref().try_duplicate(depth)?), + quant: *quant, + enclosed_groups: enclosed_groups.clone(), + } + } + + Node::Loop1CharBody { loopee, quant } => Node::Loop1CharBody { + loopee: Box::new(loopee.as_ref().try_duplicate(depth)?), + quant: *quant, + }, + + Node::CaptureGroup { .. } => { + panic!("Refusing to duplicate a capture group"); + } + &Node::WordBoundary { invert } => Node::WordBoundary { invert }, + &Node::BackRef(idx) => Node::BackRef(idx), + Node::Bracket(bc) => Node::Bracket(bc.clone()), + // Do not reverse into lookarounds, they already have the right sense. + Node::LookaroundAssertion { + negate, + backwards, + start_group, + end_group, + contents, + } => { + assert!( + start_group >= end_group, + "Cannot duplicate an assertion with enclosed groups" + ); + Node::LookaroundAssertion { + negate: *negate, + backwards: *backwards, + start_group: *start_group, + end_group: *end_group, + contents: Box::new((*contents).try_duplicate(depth)?), + } + } + }) + } +} + +/// A helper type for walking. +#[derive(Debug, Clone)] +pub struct Walk { + // It set to true, skip the children of this node. + pub skip_children: bool, + + // The current depth of the walk. + pub depth: usize, + + // If true, we are in a lookbehind (and so the cursor will move backwards). + pub in_lookbehind: bool, + + // If the regex is in unicode mode. + pub unicode: bool, +} + +impl Walk { + fn new(unicode: bool) -> Self { + Self { + skip_children: false, + depth: 0, + in_lookbehind: false, + unicode, + } + } +} + +#[derive(Debug)] +struct Walker<'a, F> +where + F: FnMut(&Node, &mut Walk), +{ + func: &'a mut F, + postorder: bool, + walk: Walk, +} + +impl Walker<'_, F> +where + F: FnMut(&Node, &mut Walk), +{ + fn process_children(&mut self, n: &Node) { + match n { + Node::Empty + | Node::Goal + | Node::Char { .. } + | Node::ByteSequence(..) + | Node::ByteSet(..) + | Node::CharSet(..) + | Node::WordBoundary { .. } + | Node::BackRef { .. } + | Node::Bracket { .. } + | Node::MatchAny + | Node::MatchAnyExceptLineTerminator + | Node::Anchor { .. } => {} + Node::Cat(nodes) => { + for node in nodes { + self.process(node); + } + } + Node::Alt(left, right) => { + self.process(left.as_ref()); + self.process(right.as_ref()); + } + + Node::Loop { loopee, .. } | Node::Loop1CharBody { loopee, .. } => self.process(loopee), + Node::CaptureGroup { contents, .. } => self.process(contents.as_ref()), + + Node::LookaroundAssertion { + backwards, + contents, + .. + } => { + let saved = self.walk.in_lookbehind; + self.walk.in_lookbehind = *backwards; + self.process(contents.as_ref()); + self.walk.in_lookbehind = saved; + } + } + } + + fn process(&mut self, n: &Node) { + self.walk.skip_children = false; + if !self.postorder { + (self.func)(n, &mut self.walk); + } + if !self.walk.skip_children { + self.walk.depth += 1; + self.process_children(n); + self.walk.depth -= 1; + } + if self.postorder { + (self.func)(n, &mut self.walk) + } + } +} + +#[derive(Debug)] +struct MutWalker<'a, F> +where + F: FnMut(&mut Node, &mut Walk), +{ + func: &'a mut F, + postorder: bool, + walk: Walk, +} + +impl MutWalker<'_, F> +where + F: FnMut(&mut Node, &mut Walk), +{ + fn process_children(&mut self, n: &mut Node) { + match n { + Node::Empty + | Node::Goal + | Node::Char { .. } + | Node::ByteSequence(..) + | Node::ByteSet(..) + | Node::CharSet(..) + | Node::MatchAny + | Node::MatchAnyExceptLineTerminator + | Node::Anchor { .. } + | Node::WordBoundary { .. } + | Node::BackRef { .. } + | Node::Bracket { .. } => {} + Node::Cat(nodes) => { + nodes.iter_mut().for_each(|node| self.process(node)); + } + Node::Alt(left, right) => { + self.process(left.as_mut()); + self.process(right.as_mut()); + } + + Node::Loop { loopee, .. } | Node::Loop1CharBody { loopee, .. } => { + self.process(loopee); + } + Node::CaptureGroup { contents, .. } => self.process(contents.as_mut()), + + Node::LookaroundAssertion { + backwards, + contents, + .. + } => { + let saved = self.walk.in_lookbehind; + self.walk.in_lookbehind = *backwards; + self.process(contents.as_mut()); + self.walk.in_lookbehind = saved; + } + } + } + + fn process(&mut self, n: &mut Node) { + self.walk.skip_children = false; + if !self.postorder { + (self.func)(n, &mut self.walk); + } + if !self.walk.skip_children { + self.walk.depth += 1; + self.process_children(n); + self.walk.depth -= 1; + } + if self.postorder { + (self.func)(n, &mut self.walk); + } + } +} + +/// Call a function on every Node. +/// If \p postorder is true, then process children before the node; +/// otherwise process children after the node. +pub fn walk(postorder: bool, unicode: bool, n: &Node, func: &mut F) +where + F: FnMut(&Node, &mut Walk), +{ + let mut walker = Walker { + func, + postorder, + walk: Walk::new(unicode), + }; + walker.process(n); +} + +/// Call a function on every Node, which may mutate the node. +/// If \p postorder is true, then process children before the node; +/// otherwise process children after the node. +/// If postorder is false, the function should return true to process children, +/// false to avoid descending into children. If postorder is true, the return +/// value is ignored. +pub fn walk_mut(postorder: bool, unicode: bool, n: &mut Node, func: &mut F) +where + F: FnMut(&mut Node, &mut Walk), +{ + let mut walker = MutWalker { + func, + postorder, + walk: Walk::new(unicode), + }; + walker.process(n); +} + +/// A regex in IR form. +pub struct Regex { + pub node: Node, + pub flags: api::Flags, +} + +impl Regex {} + +fn display_node(node: &Node, depth: usize, f: &mut fmt::Formatter) -> fmt::Result { + for _ in 0..depth { + write!(f, "..")?; + } + match node { + Node::Empty => { + writeln!(f, "Empty")?; + } + Node::Goal => { + writeln!(f, "Goal")?; + } + Node::Char { c, icase: _ } => { + writeln!(f, "'{}'", &c.to_string())?; + } + Node::ByteSequence(bytes) => { + write!(f, "ByteSeq{} 0x", bytes.len())?; + for &b in bytes { + write!(f, "{:x}", b)?; + } + writeln!(f)?; + } + Node::ByteSet(bytes) => { + let len = bytes.len(); + write!(f, "ByteSet{}", len)?; + for &b in bytes { + write!(f, " 0x{:x}", b)?; + } + writeln!(f)?; + } + Node::CharSet(chars) => { + write!(f, "CharSet ")?; + let mut first = true; + for &c in chars { + if !first { + write!(f, ", ")?; + } + first = false; + write!(f, "0x{:x}", { c })?; + } + writeln!(f)?; + } + Node::Cat(..) => { + writeln!(f, "Cat")?; + } + Node::Alt(..) => { + writeln!(f, "Alt")?; + } + Node::MatchAny => { + writeln!(f, "MatchAny")?; + } + Node::MatchAnyExceptLineTerminator => { + writeln!(f, "MatchAnyExceptLineTerminator")?; + } + Node::Anchor { + anchor_type, + multiline, + } => { + writeln!(f, "Anchor {:?} multiline={}", anchor_type, multiline)?; + } + Node::Loop { + quant, + enclosed_groups, + .. + } => { + writeln!(f, "Loop (groups {:?}) {:?}", enclosed_groups, quant)?; + } + Node::Loop1CharBody { quant, .. } => { + writeln!(f, "Loop1Char {:?}", quant)?; + } + Node::CaptureGroup { id, name, .. } => { + if let Some(name) = name { + writeln!(f, "CaptureGroup {:?} {:?}", id, name)?; + } else { + writeln!(f, "CaptureGroup {:?}", id)?; + } + } + &Node::WordBoundary { invert } => { + let kind = if invert { "\\B" } else { "\\b" }; + writeln!(f, "WordBoundary {:?} ", kind)?; + } + &Node::BackRef(group) => { + writeln!(f, "BackRef {:?} ", group)?; + } + Node::Bracket(contents) => { + writeln!(f, "Bracket {:?}", contents)?; + } + + &Node::LookaroundAssertion { + negate, + backwards, + start_group, + end_group, + .. + } => { + let sense = if negate { "negative" } else { "positive" }; + let direction = if backwards { "backwards" } else { "forwards" }; + writeln!( + f, + "LookaroundAssertion {} {} {:?} {:?}", + sense, direction, start_group, end_group + )?; + } + } + Ok(()) +} + +impl fmt::Display for Regex { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + //display_node(&self.node, 0, f) + let mut result = Ok(()); + walk( + false, + self.flags.unicode, + &self.node, + &mut |node: &Node, walk: &mut Walk| { + if result.is_ok() { + result = display_node(node, walk.depth, f) + } + }, + ); + result + } +} diff --git a/third_party/regress/src/lib.rs b/third_party/regress/src/lib.rs new file mode 100644 index 00000000..6fb33950 --- /dev/null +++ b/third_party/regress/src/lib.rs @@ -0,0 +1,187 @@ +/*! + +# regress - REGex in Rust with EcmaScript Syntax + +This crate provides a regular expression engine which targets EcmaScript (aka JavaScript) regular expression syntax. + +# Example: test if a string contains a match + +```rust +use regress::Regex; +let re = Regex::new(r"\d{4}").unwrap(); +let matched = re.find("2020-20-05").is_some(); +assert!(matched); +``` + +# Example: iterating over matches + +Here we use a backreference to find doubled characters: + +```rust +use regress::Regex; +let re = Regex::new(r"(\w)\1").unwrap(); +let text = "Frankly, Miss Piggy, I don't give a hoot!"; +for m in re.find_iter(text) { + println!("{}", &text[m.range()]) +} +// Output: ss +// Output: gg +// Output: oo + +``` + +# Example: using capture groups + +Capture groups are available in the `Match` object produced by a successful match. +A capture group is a range of byte indexes into the original string. + +```rust +use regress::Regex; +let re = Regex::new(r"(\d{4})").unwrap(); +let text = "Today is 2020-20-05"; +let m = re.find(text).unwrap(); +let group = m.group(1).unwrap(); +println!("Year: {}", &text[group]); +// Output: Year: 2020 +``` + +# Example: using with Pattern trait (nightly only) + +When the `pattern` feature is enabled and using nightly Rust, `Regex` can be used with standard string methods: + +```rust,ignore +#![feature(pattern)] +use regress::Regex; +let re = Regex::new(r"\d+").unwrap(); +let text = "abc123def456"; + +// Use with str methods +assert_eq!(text.find(&re), Some(3)); +assert!(text.contains(&re)); +let parts: Vec<&str> = text.split(&re).collect(); +assert_eq!(parts, vec!["abc", "def", ""]); +``` + +# Example: escaping strings for literal matching + +Use the `escape` function to escape special regex characters in a string: + +```rust +use regress::{escape, Regex}; +let user_input = "How much $ do you have? (in dollars)"; +let escaped = escape(user_input); +let re = Regex::new(&escaped).unwrap(); +assert!(re.find(user_input).is_some()); +``` + +# Supported Syntax + +regress targets ES 2018 syntax. You can refer to the many resources about JavaScript regex syntax. + +There are some features which have yet to be implemented: + +- Named character classes liks `[[:alpha:]]` +- Unicode property escapes like `\p{Sc}` + +Note the parser assumes the `u` (Unicode) flag, as the non-Unicode path is tied to JS's UCS-2 string encoding and the semantics cannot be usefully expressed in Rust. + +# Unicode remarks + +regress supports Unicode case folding. For example: + +```rust +use regress::Regex; +let re = Regex::with_flags("\u{00B5}", "i").unwrap(); +assert!(re.find("\u{03BC}").is_some()); +``` + +Here the U+00B5 (micro sign) was case-insensitively matched against U+03BC (small letter mu). + +regress does NOT perform normalization. For example, e-with-accute-accent can be precomposed or decomposed, and these are treated as not equivalent: + +```rust +use regress::{Regex, Flags}; +let re = Regex::new("\u{00E9}").unwrap(); +assert!(re.find("\u{0065}\u{0301}").is_none()); +``` + +This agrees with JavaScript semantics. Perform any required normalization before regex matching. + +## Ascii matching + +regress has an "ASCII mode" which treats each 8-bit quantity as a separate character. +This may provide improved performance if you do not need Unicode semantics, because it can avoid decoding UTF-8 and has simpler (ASCII-only) case-folding. + +Example: + +```rust +use regress::Regex; +let re = Regex::with_flags("BC", "i").unwrap(); +assert!(re.find("abcd").is_some()); +``` + +# Comparison to regex crate + +regress supports features (required by the EcmaScript spec) that regex does not, including backreferences and zero-width lookaround assertions. +However the regex crate provides linear-time matching guarantees, while regress does not. This difference is due +to the architecture: regex uses finite automata while regress uses "classical backtracking." + + +# Architecture + +regress has a parser, intermediate representation, optimizer which acts on the IR, bytecode emitter, and two bytecode interpreters, referred to as "backends". + +The major interpreter is the "classical backtracking" which uses an explicit backtracking stack, similar to JS implementations. There is also the "PikeVM" pseudo-toy backend which is mainly used for testing and verification. + +# Crate features + +- **utf16**. When enabled, additional APIs are made available that allow matching text formatted in UTF-16 and UCS-2 (`&[u16]`) without going through a conversion to and from UTF-8 (`&str`) first. This is particularly useful when interacting with and/or (re)implementing existing systems that use those encodings, such as JavaScript, Windows, and the JVM. + +- **pattern**. When enabled (nightly only), implements the `std::str::pattern::Pattern` trait for `Regex`, allowing it to be used with standard string methods like `str::find`, `str::contains`, `str::split`, etc. + +*/ + +#![cfg_attr(not(feature = "std"), no_std)] +#![cfg_attr(feature = "pattern", feature(pattern))] +#![warn(clippy::all)] +#![allow( + clippy::upper_case_acronyms, + clippy::match_like_matches_macro, + clippy::uninlined_format_args, + clippy::collapsible_if +)] +// Clippy's manual_range_contains suggestion produces worse codegen. +#![allow(clippy::manual_range_contains)] + +#[cfg(not(feature = "std"))] +#[macro_use] +extern crate alloc; + +pub use crate::api::*; + +#[macro_use] +mod util; + +mod api; +mod bytesearch; +mod charclasses; +mod classicalbacktrack; +mod codepointset; +mod cursor; +mod emit; +mod exec; +mod indexing; +mod insn; +mod ir; +mod matchers; +mod optimizer; +mod parse; +mod position; +mod scm; +mod startpredicate; +mod types; +mod unicode; +mod unicodetables; + +#[cfg(feature = "backend-pikevm")] +mod pikevm; diff --git a/third_party/regress/src/matchers.rs b/third_party/regress/src/matchers.rs new file mode 100644 index 00000000..72f2ec22 --- /dev/null +++ b/third_party/regress/src/matchers.rs @@ -0,0 +1,113 @@ +use crate::cursor::Direction; +use crate::indexing::{ElementType, InputIndexer}; +use crate::types::BracketContents; +use crate::unicodetables::nonascii_folds_to_ascii_word_char; +use crate::{cursor, unicode}; + +pub trait CharProperties { + type Element: ElementType; + + /// Case-fold an element. + fn fold(c: Self::Element, unicode: bool) -> Self::Element; + + /// \return whether this is a word char. + /// ES9 21.2.2.6.2. + fn is_word_char(c: Self::Element) -> bool { + let c = c.as_u32(); + 'a' as u32 <= c && c <= 'z' as u32 + || 'A' as u32 <= c && c <= 'Z' as u32 + || '0' as u32 <= c && c <= '9' as u32 + || c == '_' as u32 + } + + /// \return whether this is a word char in Unicode case-insensitive mode. + /// This includes ASCII word chars and any character that folds to an ASCII word char. + fn is_word_char_unicode_icase(c: Self::Element) -> bool { + Self::is_word_char(c) || nonascii_folds_to_ascii_word_char(c.as_u32()) + } + + /// ES9 11.3 + fn is_line_terminator(c: Self::Element) -> bool { + matches!(c.as_u32(), 0x000A | 0x000D | 0x2028 | 0x2029) + } + + /// \return whether the bracket \p bc matches the given character \p c, + /// respecting case. Respects 'invert'. + #[inline(always)] + fn bracket(bc: &BracketContents, cp: Self::Element) -> bool { + let cp = cp.into(); + if bc.cps.contains(cp) { + return !bc.invert; + } + bc.invert + } +} + +pub struct UTF8CharProperties {} + +impl CharProperties for UTF8CharProperties { + type Element = char; + + fn fold(c: Self::Element, unicode: bool) -> Self::Element { + char::from_u32(unicode::fold_code_point(c.into(), unicode)).unwrap_or(c) + } +} + +pub struct ASCIICharProperties {} +impl CharProperties for ASCIICharProperties { + type Element = u8; + + fn fold(c: Self::Element, unicode: bool) -> Self::Element { + if unicode { + c.to_ascii_lowercase() + } else { + c.to_ascii_uppercase() + } + } +} + +#[cfg(feature = "utf16")] +pub struct Utf16CharProperties {} + +#[cfg(feature = "utf16")] +impl CharProperties for Utf16CharProperties { + type Element = u32; + + fn fold(c: Self::Element, unicode: bool) -> Self::Element { + unicode::fold_code_point(c, unicode) + } +} + +/// Check whether the \p orig_range within \p cursor matches position \p pos. +pub fn backref( + input: &Input, + dir: Dir, + orig_range: core::ops::Range, + pos: &mut Input::Position, +) -> bool { + input.subrange_eq(dir, pos, orig_range) +} + +pub fn backref_icase( + input: &Input, + dir: Dir, + orig_range: core::ops::Range, + pos: &mut Input::Position, +) -> bool { + let ref_input = input.subinput(orig_range); + let mut ref_pos = if Dir::FORWARD { + ref_input.left_end() + } else { + ref_input.right_end() + }; + while let Some(c1) = cursor::next(&ref_input, dir, &mut ref_pos) { + let mut matched = false; + if let Some(c2) = cursor::next(input, dir, pos) { + matched = input.fold_equals(c1, c2) + } + if !matched { + return false; + } + } + true +} diff --git a/third_party/regress/src/optimizer.rs b/third_party/regress/src/optimizer.rs new file mode 100644 index 00000000..b604ea5c --- /dev/null +++ b/third_party/regress/src/optimizer.rs @@ -0,0 +1,544 @@ +//! Optimizations on regex IR + +use crate::insn::{MAX_BYTE_SET_LENGTH, MAX_CHAR_SET_LENGTH}; +use crate::ir::*; +use crate::types::BracketContents; +use crate::unicode; +#[cfg(not(feature = "std"))] +use alloc::{boxed::Box, vec::Vec}; + +/// When unrolling a loop, the largest minimum count we will unroll. +const LOOP_UNROLL_THRESHOLD: usize = 5; + +/// Things that a Pass may do. +pub enum PassAction { + // Do nothing to the given node. + Keep, + + // Notes that we modified the node in-place. + Modified, + + // Remove the given node outright, effectively replacing it with empty. + Remove, + + /// Replace the given node with a new Node. + Replace(Node), +} + +#[derive(Debug)] +struct Pass<'a, F> +where + F: FnMut(&mut Node, &Walk) -> PassAction, +{ + // The function. + func: &'a mut F, + + // Whether this pass has changed anything. + changed: bool, + + // If the regex is in unicode mode. + unicode: bool, +} + +impl<'a, F> Pass<'a, F> +where + F: FnMut(&mut Node, &Walk) -> PassAction, +{ + fn new(func: &'a mut F, unicode: bool) -> Self { + Pass { + func, + changed: false, + unicode, + } + } + + fn run_postorder(&mut self, start: &mut Node) { + walk_mut( + true, + self.unicode, + start, + &mut |n: &mut Node, walk: &mut Walk| match (self.func)(n, walk) { + PassAction::Keep => {} + PassAction::Modified => { + self.changed = true; + } + PassAction::Remove => { + *n = Node::Empty; + self.changed = true; + } + PassAction::Replace(newnode) => { + *n = newnode; + self.changed = true; + } + }, + ) + } + + fn run_to_fixpoint(&mut self, n: &mut Node) { + debug_assert!(!self.changed, "Pass has already been run"); + loop { + self.changed = false; + self.run_postorder(n); + if !self.changed { + break; + } + } + } +} + +/// Run a "pass" on a regex, which is a function that takes a Node and maybe +/// returns a new node. \return true if something changed, false if nothing did. +fn run_pass(r: &mut Regex, func: &mut F) -> bool +where + F: FnMut(&mut Node, &Walk) -> PassAction, +{ + let mut p = Pass::new(func, r.flags.unicode); + p.run_to_fixpoint(&mut r.node); + p.changed +} + +// Here are some optimizations we support. + +// Remove empty Nodes. +fn remove_empties(n: &mut Node, _w: &Walk) -> PassAction { + match n { + Node::Empty | Node::Goal | Node::Char { .. } => PassAction::Keep, + Node::ByteSequence(v) => { + if v.is_empty() { + PassAction::Remove + } else { + PassAction::Keep + } + } + + // Note: do not remove empty sets. These always match against one character; an empty set + // should just fail. + Node::ByteSet(..) | Node::CharSet(..) => PassAction::Keep, + Node::Cat(nodes) => { + let blen = nodes.len(); + nodes.retain(|nn| !nn.is_empty()); + if nodes.len() == blen { + // Nothing was removed. + PassAction::Keep + } else { + match nodes.len() { + 0 => PassAction::Remove, + 1 => PassAction::Replace(nodes.pop().unwrap()), + _ => PassAction::Modified, + } + } + } + Node::Alt(left, right) => { + // Empty alt may match the empty string. + // Remove it only if both sides are empty. + if left.is_empty() && right.is_empty() { + PassAction::Remove + } else { + PassAction::Keep + } + } + Node::MatchAny | Node::MatchAnyExceptLineTerminator | Node::Anchor { .. } => { + PassAction::Keep + } + Node::Loop { + quant, + loopee, + enclosed_groups, + } => { + // A loop is empty if it has an empty body, or 0 max iters. + // But do not remove contained capture groups. + if loopee.is_empty() + || (quant.max == Some(0) && enclosed_groups.start == enclosed_groups.end) + { + PassAction::Remove + } else { + PassAction::Keep + } + } + Node::Loop1CharBody { .. } => PassAction::Keep, + Node::CaptureGroup { .. } => { + // Capture groups could in principle be optimized if they only match empties. + PassAction::Keep + } + Node::WordBoundary { .. } | Node::BackRef { .. } | Node::Bracket { .. } => PassAction::Keep, + Node::LookaroundAssertion { + negate, contents, .. + } => { + // Negative arounds that match empties could in principle be optimized to always + // fail. Here we only optimize positive ones. + if !*negate && contents.is_empty() { + PassAction::Remove + } else { + PassAction::Keep + } + } + } +} + +/// Check if a node contains any capture groups (direct or nested) +fn contains_capture_groups(node: &Node) -> bool { + match node { + Node::CaptureGroup { .. } => true, + Node::Cat(nodes) => nodes.iter().any(contains_capture_groups), + Node::Alt(left, right) => contains_capture_groups(left) || contains_capture_groups(right), + Node::Loop { loopee, .. } => contains_capture_groups(loopee), + Node::LookaroundAssertion { contents, .. } => contains_capture_groups(contents), + _ => false, + } +} + +// If a node can never match, replace it with an always fails node. +fn propagate_early_fails(n: &mut Node, _w: &Walk) -> PassAction { + // Don't optimize nodes containing capture groups to preserve user-visible group numbers + if contains_capture_groups(n) { + return PassAction::Keep; + } + + match n { + Node::Cat(nodes) => { + // If any child is an early fail, we are an early fail. + // Note this assumes that there is no node after a Goal node. + if nodes.iter().any(|nn| nn.match_always_fails()) { + PassAction::Replace(Node::make_always_fails()) + } else { + PassAction::Keep + } + } + Node::Alt(left, right) => { + // If both sides are early fails, we are an early fail. + let left_fails = left.match_always_fails(); + let right_fails = right.match_always_fails(); + match (left_fails, right_fails) { + (true, true) => PassAction::Replace(Node::make_always_fails()), + (false, false) => PassAction::Keep, + (true, false) | (false, true) => { + // Here either our left or right node always fails. + // "Steal" the other and return it, replacing us. + let mut new_node = Node::Empty; + core::mem::swap( + &mut new_node, + if left_fails { &mut *right } else { &mut *left }, + ); + PassAction::Replace(new_node) + } + } + } + Node::Loop { + loopee, + quant, + enclosed_groups, + } => { + if enclosed_groups.start < enclosed_groups.end { + return PassAction::Keep; + } + // If the loop body always fails, we always fail. + if quant.min > 0 && loopee.match_always_fails() { + PassAction::Replace(Node::make_always_fails()) + } else { + PassAction::Keep + } + } + _ => PassAction::Keep, + } +} + +// Remove excess cats. +fn decat(n: &mut Node, _w: &Walk) -> PassAction { + match n { + Node::Cat(nodes) => { + if nodes.is_empty() { + PassAction::Remove + } else if nodes.len() == 1 { + PassAction::Replace(nodes.pop().unwrap()) + } else if nodes.iter().any(|nn| nn.is_cat()) { + // Flatmap child cats. + // Unfortunately we can't use flatmap() because there's no single iterator type + // we can return. + // Avoid copying nodes by switching them into owned vec. + let mut catted = Vec::new(); + core::mem::swap(nodes, &mut catted); + + // Decat them. + let mut decatted = Vec::new(); + for nn in catted { + match nn { + Node::Cat(mut nnodes) => { + decatted.append(&mut nnodes); + } + _ => decatted.push(nn), + } + } + PassAction::Replace(Node::Cat(decatted)) + } else { + PassAction::Keep + } + } + _ => PassAction::Keep, + } +} + +/// Unfold icase chars. +/// That means for case-insensitive characters, figure out everything that they +/// could match. +/// TODO: evaluate unfolding performance and consider a cache within the optimizer. +fn unfold_icase_chars(n: &mut Node, w: &Walk) -> PassAction { + match *n { + Node::Char { c, icase } if icase && !w.unicode => { + let unfolded = unicode::unfold_uppercase_char(c); + debug_assert!( + unfolded.contains(&c), + "Char should always unfold to at least itself" + ); + match unfolded.len() { + 0 => panic!("Char should always unfold to at least itself"), + 1 => { + // Character does not fold or unfold at all. + PassAction::Replace(Node::Char { c, icase: false }) + } + 2..=MAX_BYTE_SET_LENGTH => { + // We unfolded to 2+ characters. + PassAction::Replace(Node::CharSet(unfolded)) + } + _ => panic!("Unfolded to more characters than we believed possible"), + } + } + Node::Char { c, icase } if icase => { + let unfolded = unicode::unfold_char(c); + debug_assert!( + unfolded.contains(&c), + "Char should always unfold to at least itself" + ); + match unfolded.len() { + 0 => panic!("Char should always unfold to at least itself"), + 1 => { + // Character does not fold or unfold at all. + PassAction::Replace(Node::Char { c, icase: false }) + } + 2..=MAX_BYTE_SET_LENGTH => { + // We unfolded to 2+ characters. + PassAction::Replace(Node::CharSet(unfolded)) + } + _ => panic!("Unfolded to more characters than we believed possible"), + } + } + _ => PassAction::Keep, + } +} + +// Perform simple unrolling of loops that have a minimum. +fn unroll_loops(n: &mut Node, _w: &Walk) -> PassAction { + match n { + Node::Loop { + loopee, + quant, + enclosed_groups, + } => { + // TODO: consider ignoring loops with nested sub-loops? + + // Do not unroll loops with enclosed groups. + if enclosed_groups.start < enclosed_groups.end { + return PassAction::Keep; + } + // Do not unroll large loops, or loops which may execute zero times. + if quant.min == 0 || quant.min > LOOP_UNROLL_THRESHOLD { + return PassAction::Keep; + } + + // We made it through. Replace us with a cat. + let mut unrolled = Vec::new(); + for _ in 0..quant.min { + let Some(node) = loopee.try_duplicate(0) else { + return PassAction::Keep; + }; + unrolled.push(node); + } + + // We unrolled 'min' elements. + // Maybe our loop is now empty. + quant.max = quant.max.map(|v| v - quant.min); + quant.min = 0; + if quant.max != Some(0) { + // Move the loop to the end of unrolled. + let mut loop_node = Node::Empty; + core::mem::swap(&mut loop_node, n); + unrolled.push(loop_node); + } + *n = Node::Cat(unrolled); + PassAction::Modified + } + _ => PassAction::Keep, + } +} + +/// Replace Loops with 1Char loops whenever possible. +fn promote_1char_loops(n: &mut Node, _w: &Walk) -> PassAction { + match n { + Node::Loop { + loopee, + quant, + enclosed_groups, + } => { + // Must be 1Char. + if !loopee.matches_exactly_one_char() { + return PassAction::Keep; + } + + // The above check should be sufficient to ensure we have no enclosed groups. + assert!( + enclosed_groups.start >= enclosed_groups.end, + "Should have no enclosed groups" + ); + + // This feels hackish? + let mut new_loopee = Box::new(Node::Empty); + core::mem::swap(&mut new_loopee, loopee); + + *n = Node::Loop1CharBody { + loopee: new_loopee, + quant: *quant, + }; + PassAction::Modified + } + _ => PassAction::Keep, + } +} + +/// Replace Cat(Char) with ByteSeq. +/// Also replace chars with literal bytes. +/// Don't do this in utf16 mode because UTF-16 should never match against bytes. +/// TODO: this seems to do too much; consider breaking this up. +#[cfg(not(feature = "utf16"))] +fn form_literal_bytes(n: &mut Node, walk: &Walk) -> PassAction { + // Helper to return a mutable reference to the nodes of a literal bytes. + fn get_literal_bytes(n: &mut Node) -> Option<&mut Vec> { + match n { + Node::ByteSequence(v) => Some(v), + _ => None, + } + } + match n { + Node::Char { c, icase } if !*icase => { + if let Some(c) = char::from_u32(*c) { + let mut buff = [0; 4]; + PassAction::Replace(Node::ByteSequence( + c.encode_utf8(&mut buff).as_bytes().to_vec(), + )) + } else { + PassAction::Keep + } + } + Node::CharSet(chars) if chars.iter().all(|&c| c <= 0x7F) => { + // All of our chars are ASCII; use a byte set instead. + PassAction::Replace(Node::ByteSet(chars.iter().map(|&c| c as u8).collect())) + } + Node::Cat(nodes) => { + // Find and merge adjacent ByteSeq. + let mut modified = false; + for idx in 1..nodes.len() { + let (prev_slice, curr_slice) = nodes.split_at_mut(idx); + match ( + get_literal_bytes(prev_slice.last_mut().unwrap()), + get_literal_bytes(curr_slice.first_mut().unwrap()), + ) { + (Some(prev_bytes), Some(curr_bytes)) + if !prev_bytes.is_empty() && !curr_bytes.is_empty() => + { + if walk.in_lookbehind { + // Our characters were already reversed; we need to reverse them again + // as literal bytes are always forwards. For + // example, if we have (<=ab), then we will get Cat(b, a) but we want + // literal bytes "ab". + curr_bytes.append(prev_bytes); + } else { + prev_bytes.append(curr_bytes); + core::mem::swap(prev_bytes, curr_bytes); + } + modified = true; + } + _ => (), + } + } + if modified { + PassAction::Modified + } else { + PassAction::Keep + } + } + _ => PassAction::Keep, + } +} + +/// Try to reduce a bracket to something simpler. +fn try_reduce_bracket(bc: &BracketContents) -> Option { + if bc.invert { + // Give up. + return None; + } + + // Count the number of code points. + let mut cps_count = 0; + for iv in bc.cps.intervals() { + cps_count += iv.count_codepoints(); + } + if cps_count > MAX_CHAR_SET_LENGTH { + // Too many code points. + return None; + } + // Ok, we want to make a char set. + // Note we cannot make a char out of surrogates; should char conversion fail we + // just give up. + let mut res = Vec::new(); + for iv in bc.cps.intervals() { + for cp in iv.codepoints() { + res.push(cp); + } + } + debug_assert!(res.len() <= MAX_CHAR_SET_LENGTH, "Unexpectedly many chars"); + Some(Node::CharSet(res)) +} + +/// Optimize brackets like [a-b]. +/// Optimize certain stupid brackets like `[a]` to a single char. +/// Invert a bracket if it would *reduce* the number of ranges. +/// Note we only run this once. +fn simplify_brackets(n: &mut Node, _walk: &Walk) -> PassAction { + match n { + Node::Bracket(bc) => { + if let Some(new_node) = try_reduce_bracket(bc) { + return PassAction::Replace(new_node); + } + + // TODO: does this ever help anything? + if bc.cps.intervals().len() > bc.cps.inverted_interval_count() { + bc.cps = bc.cps.inverted(); + bc.invert = !bc.invert; + PassAction::Modified + } else { + PassAction::Keep + } + } + _ => PassAction::Keep, + } +} + +pub fn optimize(r: &mut Regex) { + run_pass(r, &mut simplify_brackets); + loop { + let mut changed = false; + changed |= run_pass(r, &mut decat); + if r.flags.icase { + changed |= run_pass(r, &mut unfold_icase_chars); + } + changed |= run_pass(r, &mut unroll_loops); + changed |= run_pass(r, &mut promote_1char_loops); + #[cfg(not(feature = "utf16"))] + { + changed |= run_pass(r, &mut form_literal_bytes); + } + changed |= run_pass(r, &mut remove_empties); + changed |= run_pass(r, &mut propagate_early_fails); + if !changed { + break; + } + } +} diff --git a/third_party/regress/src/parse.rs b/third_party/regress/src/parse.rs new file mode 100644 index 00000000..a4057064 --- /dev/null +++ b/third_party/regress/src/parse.rs @@ -0,0 +1,2078 @@ +//! Parser from regex patterns to IR + +use crate::{ + api, charclasses, + codepointset::{CodePointSet, Interval, interval_contains}, + ir, + types::{ + BracketContents, CaptureGroupID, CaptureGroupName, CharacterClassType, MAX_CAPTURE_GROUPS, + MAX_LOOPS, + }, + unicode::{ + self, PropertyEscapeKind, unicode_property_from_str, unicode_property_name_from_str, + }, + unicodetables::{id_continue_ranges, id_start_ranges}, + util::to_char_sat, +}; +use core::{fmt, iter::Peekable}; +#[cfg(feature = "std")] +use std::collections::HashMap; +#[cfg(not(feature = "std"))] +use { + alloc::{ + boxed::Box, + string::{String, ToString}, + vec::Vec, + }, + hashbrown::HashMap, +}; + +/// Represents an error encountered during regex compilation. +/// +/// The text contains a human-readable error message. +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Error { + pub text: String, +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(&self.text) + } +} + +#[cfg(feature = "std")] +impl std::error::Error for Error {} + +enum ClassAtom { + CodePoint(u32), + CharacterClass { + class_type: CharacterClassType, + positive: bool, + }, + Range { + iv: CodePointSet, + negate: bool, + }, +} + +/// Represents the result of a class set. +#[derive(Debug, Clone)] +struct ClassSet { + codepoints: CodePointSet, + alternatives: ClassSetAlternativeStrings, +} + +impl ClassSet { + fn new() -> Self { + ClassSet { + codepoints: CodePointSet::new(), + alternatives: ClassSetAlternativeStrings::new(), + } + } + + fn node(self, icase: bool, negate_set: bool) -> ir::Node { + let codepoints = if icase { + unicode::add_icase_code_points(self.codepoints) + } else { + self.codepoints + }; + if codepoints.is_empty() && self.alternatives.0.is_empty() { + ir::Node::Bracket(BracketContents { + invert: negate_set, + cps: codepoints, + }) + } else if codepoints.is_empty() { + make_alt(self.alternatives.to_nodes(icase)) + } else if self.alternatives.0.is_empty() { + ir::Node::Bracket(BracketContents { + invert: negate_set, + cps: codepoints, + }) + } else { + let mut nodes = self.alternatives.to_nodes(icase); + nodes.push(ir::Node::Bracket(BracketContents { + invert: negate_set, + cps: codepoints, + })); + make_alt(nodes) + } + } + + fn union_operand(&mut self, operand: ClassSetOperand) { + match operand { + ClassSetOperand::ClassSetCharacter(c) => { + self.codepoints.add_one(c); + } + ClassSetOperand::CharacterClassEscape(cps) => { + self.codepoints.add_set(cps); + } + ClassSetOperand::Class(class) => { + self.codepoints.add_set(class.codepoints); + self.alternatives.extend(class.alternatives); + } + ClassSetOperand::ClassStringDisjunction(s) => { + self.alternatives.extend(s); + } + } + } + + fn intersect_operand(&mut self, operand: ClassSetOperand) { + match operand { + ClassSetOperand::ClassSetCharacter(c) => { + if self.codepoints.contains(c) { + self.codepoints = + CodePointSet::from_sorted_disjoint_intervals(Vec::from([Interval { + first: c, + last: c, + }])); + } else { + self.codepoints.clear(); + } + let mut found_alternative = false; + for alternative in &mut self.alternatives.0 { + if alternative.len() == 1 && alternative[0] == c { + found_alternative = true; + break; + } + } + self.alternatives.0.clear(); + if found_alternative { + self.alternatives.0.push(Vec::from([c])); + } + } + ClassSetOperand::CharacterClassEscape(cps) => { + self.codepoints.intersect(cps.intervals()); + let mut retained = Vec::new(); + for alternative in &self.alternatives.0 { + if alternative.len() == 1 && cps.contains(alternative[0]) { + retained.push(alternative.clone()); + } + } + self.alternatives.0 = retained; + } + ClassSetOperand::Class(class) => { + let mut retained_codepoints = CodePointSet::new(); + for alternative in &class.alternatives.0 { + if alternative.len() == 1 && self.codepoints.contains(alternative[0]) { + retained_codepoints.add_one(alternative[0]); + } + } + let mut retained_alternatives = ClassSetAlternativeStrings::new(); + for alternative in &self.alternatives.0 { + if alternative.len() == 1 && class.codepoints.contains(alternative[0]) { + retained_alternatives.0.push(alternative.clone()); + } + } + self.codepoints.intersect(class.codepoints.intervals()); + self.codepoints.add_set(retained_codepoints); + self.alternatives.intersect(class.alternatives); + self.alternatives.extend(retained_alternatives); + } + ClassSetOperand::ClassStringDisjunction(s) => { + let mut retained = CodePointSet::new(); + for alternative in &s.0 { + if alternative.len() == 1 && self.codepoints.contains(alternative[0]) { + retained.add_one(alternative[0]); + } + } + self.codepoints = retained; + self.alternatives.intersect(s); + } + } + } + + fn subtract_operand(&mut self, operand: ClassSetOperand) { + match operand { + ClassSetOperand::ClassSetCharacter(c) => { + self.codepoints.remove(&[Interval { first: c, last: c }]); + self.alternatives + .remove(ClassSetAlternativeStrings(Vec::from([Vec::from([c])]))); + } + ClassSetOperand::CharacterClassEscape(cps) => { + self.codepoints.remove(cps.intervals()); + let mut to_remove = ClassSetAlternativeStrings::new(); + for alternative in &self.alternatives.0 { + if alternative.len() == 1 && cps.contains(alternative[0]) { + to_remove.0.push(alternative.clone()); + } + } + self.alternatives.remove(to_remove); + } + ClassSetOperand::Class(class) => { + let mut codepoints_removed = CodePointSet::new(); + for alternative in &class.alternatives.0 { + if alternative.len() == 1 && self.codepoints.contains(alternative[0]) { + codepoints_removed.add_one(alternative[0]); + } + } + let mut alternatives_removed = ClassSetAlternativeStrings::new(); + for alternative in &self.alternatives.0 { + if alternative.len() == 1 && class.codepoints.contains(alternative[0]) { + alternatives_removed.0.push(alternative.clone()); + } + } + self.codepoints.remove(codepoints_removed.intervals()); + self.codepoints.remove(class.codepoints.intervals()); + self.alternatives.remove(alternatives_removed); + self.alternatives.remove(class.alternatives); + } + ClassSetOperand::ClassStringDisjunction(s) => { + let mut to_remove = CodePointSet::new(); + for alternative in &s.0 { + if alternative.len() == 1 && self.codepoints.contains(alternative[0]) { + to_remove.add_one(alternative[0]); + } + } + self.codepoints.remove(to_remove.intervals()); + self.alternatives.remove(s); + } + } + } +} + +/// Represents all different types of class set operands. +#[derive(Debug, Clone)] +enum ClassSetOperand { + ClassSetCharacter(u32), + CharacterClassEscape(CodePointSet), + Class(ClassSet), + ClassStringDisjunction(ClassSetAlternativeStrings), +} + +#[derive(Debug, Clone)] +struct ClassSetAlternativeStrings(Vec>); + +impl ClassSetAlternativeStrings { + fn new() -> Self { + ClassSetAlternativeStrings(Vec::new()) + } + + fn extend(&mut self, other: Self) { + self.0.extend(other.0); + } + + fn intersect(&mut self, other: Self) { + let mut retained = Vec::new(); + for string in &self.0 { + for other_string in &other.0 { + if string == other_string { + retained.push(string.clone()); + break; + } + } + } + self.0 = retained; + } + + fn remove(&mut self, other: Self) { + self.0.retain(|string| !other.0.contains(string)); + } + + fn to_nodes(&self, icase: bool) -> Vec { + let mut nodes = Vec::new(); + for string in &self.0 { + nodes.push(ir::Node::Cat( + string + .iter() + .map(|cp| ir::Node::Char { c: *cp, icase }) + .collect::>(), + )); + } + nodes + } +} + +fn error(text: S) -> Result +where + S: ToString, +{ + Err(Error { + text: text.to_string(), + }) +} + +fn make_cat(nodes: ir::NodeList) -> ir::Node { + match nodes.len() { + 0 => ir::Node::Empty, + 1 => nodes.into_iter().next().unwrap(), + _ => ir::Node::Cat(nodes), + } +} + +fn make_alt(nodes: ir::NodeList) -> ir::Node { + let mut mright = None; + for node in nodes.into_iter().rev() { + match mright { + None => mright = Some(node), + Some(right) => mright = Some(ir::Node::Alt(Box::new(node), Box::new(right))), + } + } + mright.unwrap_or(ir::Node::Empty) +} + +/// \return a CodePointSet for a given character escape (positive or negative). +/// See ES9 21.2.2.12. +/// Returns the positive (non-inverted) code point set for a character class. +fn codepoints_from_class_positive(ct: CharacterClassType) -> CodePointSet { + let mut cps; + match ct { + CharacterClassType::Digits => { + cps = CodePointSet::from_sorted_disjoint_intervals(charclasses::DIGITS.to_vec()) + } + CharacterClassType::Words => { + cps = CodePointSet::from_sorted_disjoint_intervals(charclasses::WORD_CHARS.to_vec()) + } + CharacterClassType::Spaces => { + cps = CodePointSet::from_sorted_disjoint_intervals(charclasses::WHITESPACE.to_vec()); + for &iv in charclasses::LINE_TERMINATOR.iter() { + cps.add(iv) + } + } + } + cps +} + +/// Returns code points for a character class, optionally inverted. +fn codepoints_from_class(ct: CharacterClassType, positive: bool) -> CodePointSet { + let cps = codepoints_from_class_positive(ct); + if positive { cps } else { cps.inverted() } +} + +/// \return a Bracket for a given character escape (positive or negative). +/// For icase mode, we expand the positive set first, then invert if needed. +fn make_bracket_class(ct: CharacterClassType, positive: bool, icase: bool) -> ir::Node { + // Get the positive (non-inverted) set, perform any icase expansion, then maybe invert. + let mut cps = codepoints_from_class_positive(ct); + if icase { + cps = unicode::add_icase_code_points(cps); + } + if !positive { + cps = cps.inverted(); + } + ir::Node::Bracket(BracketContents { invert: false, cps }) +} + +fn add_class_atom(bc: &mut BracketContents, atom: ClassAtom) { + match atom { + ClassAtom::CodePoint(c) => bc.cps.add_one(c), + ClassAtom::CharacterClass { + class_type, + positive, + } => { + bc.cps.add_set(codepoints_from_class(class_type, positive)); + } + ClassAtom::Range { iv, negate } => { + if negate { + bc.cps.add_set(iv.inverted()); + } else { + bc.cps.add_set(iv); + } + } + } +} + +struct LookaroundParams { + negate: bool, + backwards: bool, +} + +/// Represents an alternative path in a regex pattern. +/// For example, in `/(?x)|(?y)/`, the two occurrences of 'a' are in different +/// alternative paths (separated by |), so they don't conflict. +/// Each element in the vector is (depth, alternative_index) where: +/// - depth: parenthesis nesting level (0 = top level) +/// - alternative_index: which alternative at that depth (0 = first, 1 = second after |, etc.) +#[derive(Debug, Clone, PartialEq, Eq)] +struct AlternativePath { + /// Vector of (depth, alternative_index) pairs representing the path through alternatives + segments: Vec<(usize, usize)>, +} + +impl AlternativePath { + /// Check if two alternative paths conflict (i.e., are in the same alternative branch). + /// Two paths conflict if they share the same alternative indices at all common depth levels. + /// Example: + /// - [(0, 0)] and [(0, 0), (1, 0)] conflict (second is nested within first) + /// - [(0, 0)] and [(0, 1)] don't conflict (different alternatives at depth 0) + fn conflicts_with(&self, other: &AlternativePath) -> bool { + let min_len = self.segments.len().min(other.segments.len()); + self.segments[..min_len] == other.segments[..min_len] + } +} + +/// Represents the state used to parse a regex. +struct Parser +where + I: Iterator, +{ + /// The remaining input. + input: Peekable, + + /// Flags used. + flags: api::Flags, + + /// Number of loops. + loop_count: u32, + + /// Number of capturing groups. + group_count: CaptureGroupID, + + /// Maximum number of capturing groups. + group_count_max: u32, + + /// A map each from capture group name to corresponding group indices in order. + /// Note duplicate names may appear in distinct alternations, per the TC39 proposal. + /// See + named_group_indices: HashMap>, + + /// Whether a lookbehind was encountered. + has_lookbehind: bool, +} + +impl Parser +where + I: Iterator + Clone, +{ + /// Consume a character, returning it. + fn consume>(&mut self, c: C) -> u32 { + let nc = self.input.next(); + core::debug_assert!(nc == Some(c.into()), "char was not next"); + nc.unwrap() + } + + /// If our contents begin with the char c, consume it from our contents + /// and return true. Otherwise return false. + fn try_consume>(&mut self, c: C) -> bool { + self.input.next_if_eq(&c.into()).is_some() + } + + /// If our contents begin with the string \p s, consume it from our contents + /// and return true. Otherwise return false. + fn try_consume_str(&mut self, s: &str) -> bool { + let mut cursor = self.input.clone(); + for c1 in s.chars() { + if cursor.next() != Some(c1 as u32) { + return false; + } + } + self.input = cursor; + true + } + + /// Fold a character if icase. + fn fold_if_icase(&self, c: u32) -> u32 { + if self.flags.icase { + unicode::fold_code_point(c, self.flags.unicode) + } else { + c + } + } + + /// Peek at the next character. + fn peek(&mut self) -> Option { + self.input.peek().copied() + } + + /// \return the next character. + fn next(&mut self) -> Option { + self.input.next() + } + + fn try_parse(&mut self) -> Result { + self.parse_capture_groups()?; + + // Parse a catenation. If we consume everything, it's success. If there's + // something left, it's an error (for example, an excess closing paren). + let body = self.consume_disjunction()?; + match self.input.peek().copied() { + Some(c) if c == ')' as u32 => error("Unbalanced parenthesis"), + Some(c) => error(format!( + "Unexpected char: {}", + char::from_u32(c) + .map(String::from) + .unwrap_or_else(|| format!("\\u{c:04X}")) + )), + None => self.finalize(ir::Regex { + node: make_cat(vec![body, ir::Node::Goal]), + flags: self.flags, + }), + } + } + + /// ES6 21.2.2.3 Disjunction. + fn consume_disjunction(&mut self) -> Result { + let mut terms = vec![self.consume_term()?]; + while self.try_consume('|') { + terms.push(self.consume_term()?) + } + Ok(make_alt(terms)) + } + + /// ES6 21.2.2.5 Term. + fn consume_term(&mut self) -> Result { + let mut result: Vec = Vec::new(); + loop { + let start_group = self.group_count; + let mut start_offset = result.len(); + let mut quantifier_allowed = true; + + let nc = self.peek(); + if nc.is_none() { + return Ok(make_cat(result)); + } + let c = nc.unwrap(); + match to_char_sat(c) { + // A concatenation is terminated by closing parens or vertical bar (alternations). + ')' | '|' => break, + // Term :: Assertion :: ^ + '^' => { + self.consume('^'); + result.push(ir::Node::Anchor { + anchor_type: ir::AnchorType::StartOfLine, + multiline: self.flags.multiline, + }); + quantifier_allowed = false; + } + // Term :: Assertion :: $ + '$' => { + self.consume('$'); + result.push(ir::Node::Anchor { + anchor_type: ir::AnchorType::EndOfLine, + multiline: self.flags.multiline, + }); + quantifier_allowed = false; + } + + '\\' => { + self.consume('\\'); + let Some(c) = self.peek() else { + return error("Incomplete escape"); + }; + match to_char_sat(c) { + // Term :: Assertion :: \b + 'b' => { + self.consume('b'); + result.push(ir::Node::WordBoundary { invert: false }); + } + // Term :: Assertion :: \B + 'B' => { + self.consume('B'); + result.push(ir::Node::WordBoundary { invert: true }); + } + // Term :: Atom :: \ AtomEscape :: CharacterEscape :: c AsciiLetter + // Term :: ExtendedAtom :: \ [lookahead = c] + 'c' if !self.flags.unicode => { + self.consume('c'); + if self + .peek() + .and_then(char::from_u32) + .map(|c| c.is_ascii_alphabetic()) + == Some(true) + { + result.push(ir::Node::Char { + c: self.next().expect("char was not next") % 32, + icase: self.flags.icase, + }); + } else { + start_offset += 1; + result.push(ir::Node::Char { + c: u32::from('\\'), + icase: self.flags.icase, + }); + result.push(ir::Node::Char { + c: u32::from('c'), + icase: self.flags.icase, + }); + } + } + // Term :: Atom :: \ AtomEscape + _ => { + result.push(self.consume_atom_escape()?); + } + } + } + + // Term :: Atom :: . + '.' => { + self.consume('.'); + result.push(if self.flags.dot_all { + ir::Node::MatchAny + } else { + ir::Node::MatchAnyExceptLineTerminator + }); + } + + '(' => { + if self.try_consume_str("(?=") { + // Positive lookahead. + quantifier_allowed = !self.flags.unicode; + result.push(self.consume_lookaround_assertion(LookaroundParams { + negate: false, + backwards: false, + })?); + } else if self.try_consume_str("(?!") { + // Negative lookahead. + quantifier_allowed = !self.flags.unicode; + result.push(self.consume_lookaround_assertion(LookaroundParams { + negate: true, + backwards: false, + })?); + } else if self.try_consume_str("(?<=") { + // Positive lookbehind. + quantifier_allowed = false; + self.has_lookbehind = true; + result.push(self.consume_lookaround_assertion(LookaroundParams { + negate: false, + backwards: true, + })?); + } else if self.try_consume_str("(?= MAX_CAPTURE_GROUPS { + return error("Capture group count limit exceeded"); + } + self.group_count += 1; + + // Maybe the capture group has a name! + let mut group_name = None; + if self.try_consume_str("?") { + group_name = self.try_consume_named_capture_group_name(); + if group_name.is_none() { + return error("Invalid token at named capture group identifier"); + }; + } + let contents = Box::new(self.consume_disjunction()?); + result.push(ir::Node::CaptureGroup { + id: group, + contents, + name: group_name, + }) + } + if !self.try_consume(')') { + return error("Unbalanced parenthesis"); + } + } + + // CharacterClass :: ClassContents :: ClassSetExpression + '[' if self.flags.unicode_sets => { + self.consume('['); + let negate_set = self.try_consume('^'); + result.push( + self.consume_class_set_expression(negate_set)? + .node(self.flags.icase, negate_set), + ); + } + + '[' => { + result.push(self.consume_bracket()?); + } + + // Term :: ExtendedAtom :: InvalidBracedQuantifier + '{' if !self.flags.unicode => { + if self.try_consume_braced_quantifier().is_some() { + return error("Invalid braced quantifier"); + } + + // Term :: ExtendedAtom :: ExtendedPatternCharacter + result.push(ir::Node::Char { + c: self.consume(c), + icase: self.flags.icase, + }) + } + + // Term :: Atom :: PatternCharacter :: SourceCharacter but not ^ $ \ . * + ? ( ) [ ] { } | + '*' | '+' | '?' | ']' | '{' | '}' if self.flags.unicode => { + return error("Invalid atom character"); + } + + // Term :: ExtendedAtom :: SourceCharacter but not ^ $ \ . * + ? ( ) [ | + '*' | '+' | '?' => { + return error("Invalid atom character"); + } + + // Term :: Atom :: PatternCharacter + // Term :: ExtendedAtom :: ExtendedPatternCharacter + _ => { + self.consume(c); + result.push(ir::Node::Char { + c: self.fold_if_icase(c), + icase: self.flags.icase, + }) + } + } + + // We just parsed a term; try parsing a quantifier. + if let Some(quant) = self.try_consume_quantifier()? { + if !quantifier_allowed { + return error("Quantifier not allowed here"); + } + // Validate the quantifier. + // Note we don't want to do this as part of parsing the quantiifer in some cases + // an incomplete quantifier is not recognized as a quantifier, e.g. `/{3/` is + // valid. + if matches!(quant.max, Some(max) if quant.min > max) { + return error("Invalid quantifier"); + } + let quantifee = result.split_off(start_offset); + if self.loop_count as usize >= MAX_LOOPS { + return error("Loop count limit exceeded"); + } + self.loop_count += 1; + result.push(ir::Node::Loop { + loopee: Box::new(make_cat(quantifee)), + quant, + enclosed_groups: start_group..self.group_count, + }); + } + } + Ok(make_cat(result)) + } + + fn try_consume_modifier_group(&mut self) -> Result, Error> { + let mut cursor = self.input.clone(); + if cursor.next() != Some('(' as u32) { + return Ok(None); + } + if cursor.next() != Some('?' as u32) { + return Ok(None); + } + let Some(mut current) = cursor.next() else { + return Ok(None); + }; + + if to_char_sat(current) == '<' { + return Ok(None); + } + + let mut seen_hyphen = false; + let mut saw_flag = false; + let mut icase_override: Option = None; + let mut multiline_override: Option = None; + let mut dot_all_override: Option = None; + + loop { + let ch = to_char_sat(current); + match ch { + 'i' | 'm' | 's' => { + let value = !seen_hyphen; + let target = match ch { + 'i' => &mut icase_override, + 'm' => &mut multiline_override, + 's' => &mut dot_all_override, + _ => unreachable!(), + }; + if target.is_some() { + return error("Invalid group modifier"); + } + *target = Some(value); + saw_flag = true; + } + '-' => { + if seen_hyphen { + return error("Invalid group modifier"); + } + seen_hyphen = true; + } + ':' => { + if !saw_flag { + return error("Invalid group modifier"); + } + self.input = cursor; + let mut new_flags = self.flags; + if let Some(value) = icase_override { + new_flags.icase = value; + } + if let Some(value) = multiline_override { + new_flags.multiline = value; + } + if let Some(value) = dot_all_override { + new_flags.dot_all = value; + } + let saved_flags = self.flags; + self.flags = new_flags; + let contents = match self.consume_disjunction() { + Ok(node) => node, + Err(err) => { + self.flags = saved_flags; + return Err(err); + } + }; + self.flags = saved_flags; + return Ok(Some(contents)); + } + _ => { + return error("Invalid group modifier"); + } + } + + current = match cursor.next() { + Some(next) => next, + None => return error("Invalid group modifier"), + }; + } + } + + /// ES6 21.2.2.13 CharacterClass. + fn consume_bracket(&mut self) -> Result { + self.consume('['); + let invert = self.try_consume('^'); + let mut result = BracketContents { + invert, + cps: CodePointSet::default(), + }; + + loop { + match self.peek().map(to_char_sat) { + None => { + return error("Unbalanced bracket"); + } + Some(']') => { + self.consume(']'); + if self.flags.icase { + result.cps = unicode::add_icase_code_points(result.cps); + } + return Ok(ir::Node::Bracket(result)); + } + _ => {} + } + + // Parse a code point or character class. + let Some(first) = self.try_consume_bracket_class_atom()? else { + continue; + }; + + // Check for a dash; we may have a range. + if !self.try_consume('-') { + add_class_atom(&mut result, first); + continue; + } + + let Some(second) = self.try_consume_bracket_class_atom()? else { + // No second atom. For example: [a-]. + add_class_atom(&mut result, first); + add_class_atom(&mut result, ClassAtom::CodePoint(u32::from('-'))); + continue; + }; + + // Ranges must also be in order: z-a is invalid. + // ES6 21.2.2.15.1 "If i > j, throw a SyntaxError exception" + if let (ClassAtom::CodePoint(c1), ClassAtom::CodePoint(c2)) = (&first, &second) { + if c1 > c2 { + return error( + "Range values reversed, start char code is greater than end char code.", + ); + } + result.cps.add(Interval { + first: *c1, + last: *c2, + }); + + continue; + } + + if self.flags.unicode { + return error("Invalid character range"); + } + + // If it does not match a range treat as any match single characters. + add_class_atom(&mut result, first); + add_class_atom(&mut result, ClassAtom::CodePoint(u32::from('-'))); + add_class_atom(&mut result, second); + } + } + + fn try_consume_bracket_class_atom(&mut self) -> Result, Error> { + let c = self.peek(); + if c.is_none() { + return Ok(None); + } + let c = c.unwrap(); + match to_char_sat(c) { + // End of bracket. + ']' => Ok(None), + + // ClassEscape + '\\' => { + self.consume('\\'); + let ec = if let Some(ec) = self.peek() { + ec + } else { + return error("Unterminated escape"); + }; + match to_char_sat(ec) { + // ClassEscape :: b + 'b' => { + self.consume('b'); + Ok(Some(ClassAtom::CodePoint(u32::from('\x08')))) + } + // ClassEscape :: [+UnicodeMode] - + '-' if self.flags.unicode => { + self.consume('-'); + Ok(Some(ClassAtom::CodePoint(u32::from('-')))) + } + 'c' if !self.flags.unicode => { + let input = self.input.clone(); + self.consume('c'); + match self.peek().map(to_char_sat) { + // ClassEscape :: [~UnicodeMode] c ClassControlLetter + Some('0'..='9' | '_') => { + let next = self.next().expect("char was not next"); + Ok(Some(ClassAtom::CodePoint(next & 0x1F))) + } + // CharacterEscape :: c AsciiLetter + Some('a'..='z' | 'A'..='Z') => { + let next = self.next().expect("char was not next"); + Ok(Some(ClassAtom::CodePoint(next % 32))) + } + // ClassAtomNoDash :: \ [lookahead = c] + _ => { + self.input = input; + Ok(Some(ClassAtom::CodePoint(u32::from('\\')))) + } + } + } + // ClassEscape :: CharacterClassEscape :: d + 'd' => { + self.consume('d'); + Ok(Some(ClassAtom::CharacterClass { + class_type: CharacterClassType::Digits, + positive: true, + })) + } + // ClassEscape :: CharacterClassEscape :: D + 'D' => { + self.consume('D'); + Ok(Some(ClassAtom::CharacterClass { + class_type: CharacterClassType::Digits, + positive: false, + })) + } + // ClassEscape :: CharacterClassEscape :: s + 's' => { + self.consume('s'); + Ok(Some(ClassAtom::CharacterClass { + class_type: CharacterClassType::Spaces, + positive: true, + })) + } + // ClassEscape :: CharacterClassEscape :: S + 'S' => { + self.consume('S'); + Ok(Some(ClassAtom::CharacterClass { + class_type: CharacterClassType::Spaces, + positive: false, + })) + } + // ClassEscape :: CharacterClassEscape :: w + 'w' => { + self.consume('w'); + Ok(Some(ClassAtom::CharacterClass { + class_type: CharacterClassType::Words, + positive: true, + })) + } + // ClassEscape :: CharacterClassEscape :: W + 'W' => { + self.consume('W'); + Ok(Some(ClassAtom::CharacterClass { + class_type: CharacterClassType::Words, + positive: false, + })) + } + // ClassEscape :: CharacterClassEscape :: [+UnicodeMode] p{ UnicodePropertyValueExpression } + // ClassEscape :: CharacterClassEscape :: [+UnicodeMode] P{ UnicodePropertyValueExpression } + 'p' | 'P' if self.flags.unicode => { + self.consume(ec); + let negate = ec == 'P' as u32; + match self.try_consume_unicode_property_escape()? { + PropertyEscapeKind::CharacterClass(s) => Ok(Some(ClassAtom::Range { + iv: CodePointSet::from_sorted_disjoint_intervals(s.to_vec()), + negate, + })), + PropertyEscapeKind::StringSet(_) => error("Invalid property escape"), + } + } + // ClassEscape :: CharacterEscape + _ => { + let cc = self.consume_character_escape()?; + Ok(Some(ClassAtom::CodePoint(cc))) + } + } + } + + _ => Ok(Some(ClassAtom::CodePoint(self.consume(c)))), + } + } + + // CharacterClass :: ClassContents :: ClassSetExpression + fn consume_class_set_expression(&mut self, negate_set: bool) -> Result { + let mut result = ClassSet::new(); + + let first = match self.peek() { + Some(0x5D /* ] */) => { + self.consume(']'); + return Ok(result); + } + Some(_) => self.consume_class_set_operand(negate_set)?, + None => { + return error("Unbalanced class set bracket"); + } + }; + + enum ClassSetOperator { + Union, + Intersection, + Subtraction, + } + + let op = match self.peek() { + Some(0x5D /* ] */) => { + self.consume(']'); + result.union_operand(first); + return Ok(result); + } + Some(0x26 /* & */) => { + self.consume('&'); + if self.peek() == Some(0x26 /* & */) { + self.consume('&'); + result.union_operand(first.clone()); + ClassSetOperator::Intersection + } else { + result.codepoints.add_one(0x26 /* & */); + ClassSetOperator::Union + } + } + Some(0x2D /* - */) => { + self.consume('-'); + if self.peek() == Some(0x2D /* - */) { + self.consume('-'); + result.union_operand(first.clone()); + ClassSetOperator::Subtraction + } else { + match first { + ClassSetOperand::ClassSetCharacter(first) => { + let ClassSetOperand::ClassSetCharacter(last) = + self.consume_class_set_operand(negate_set)? + else { + return error("Invalid class set range"); + }; + if first > last { + return error("Invalid class set range"); + } + result.codepoints.add(Interval { first, last }); + } + _ => { + return error("Invalid class set range"); + } + }; + ClassSetOperator::Union + } + } + Some(_) => { + result.union_operand(first.clone()); + ClassSetOperator::Union + } + None => { + return error("Unbalanced class set bracket"); + } + }; + + match op { + ClassSetOperator::Union => { + loop { + let operand = match self.peek() { + Some(0x5D /* ] */) => { + self.consume(']'); + return Ok(result); + } + Some(_) => self.consume_class_set_operand(negate_set)?, + None => return error("Unbalanced class set bracket"), + }; + if self.peek() == Some(0x2D /* - */) { + self.consume('-'); + match operand { + ClassSetOperand::ClassSetCharacter(first) => { + let ClassSetOperand::ClassSetCharacter(last) = + self.consume_class_set_operand(negate_set)? + else { + return error("Invalid class set range"); + }; + if first > last { + return error("Invalid class set range"); + } + result.codepoints.add(Interval { first, last }); + } + _ => { + return error("Invalid class set range"); + } + }; + } else { + result.union_operand(operand); + } + } + } + // ClassIntersection :: ClassSetOperand && [lookahead ≠ &] + ClassSetOperator::Intersection => { + loop { + let operand = self.consume_class_set_operand(negate_set)?; + result.intersect_operand(operand); + match self.next() { + Some(0x5D /* ] */) => return Ok(result), + Some(0x26 /* & */) => {} + Some(_) => return error("Unexpected character in class set intersection"), + _ => return error("Unbalanced class set bracket"), + } + if self.next() != Some(0x26 /* & */) { + return error("Unbalanced class set bracket"); + } + } + } + // ClassSubtraction :: ClassSubtraction -- ClassSetOperand + ClassSetOperator::Subtraction => { + loop { + let operand = self.consume_class_set_operand(negate_set)?; + result.subtract_operand(operand); + match self.next() { + Some(0x5D /* ] */) => return Ok(result), + Some(0x2D /* - */) => {} + Some(_) => return error("Unexpected character in class set subtraction"), + _ => return error("Unbalanced class set bracket"), + } + if self.next() != Some(0x2D /* - */) { + return error("Unbalanced class set bracket"); + } + } + } + } + } + + fn consume_class_set_operand(&mut self, negate_set: bool) -> Result { + use ClassSetOperand::*; + let Some(cp) = self.peek() else { + return error("Empty class set operand"); + }; + match cp { + // ClassSetOperand :: NestedClass :: [ [lookahead ≠ ^] ClassContents[+UnicodeMode, +UnicodeSetsMode] ] + // ClassSetOperand :: NestedClass :: [^ ClassContents[+UnicodeMode, +UnicodeSetsMode] ] + 0x5B /* [ */ => { + self.consume('['); + let negate_set = self.try_consume('^'); + let result = self.consume_class_set_expression(negate_set)?; + if negate_set { + result.codepoints.inverted(); + } + Ok(Class(result)) + } + // ClassSetOperand :: NestedClass :: \ CharacterClassEscape + // ClassSetOperand :: ClassStringDisjunction + // ClassSetOperand :: ClassSetCharacter :: \... + // ClassSetRange :: ClassSetCharacter :: \... + 0x5C /* \ */ => { + self.consume('\\'); + let Some(cp) = self.peek() else { + return error("Incomplete class set escape"); + }; + match cp { + // ClassStringDisjunction \q{ ClassStringDisjunctionContents } + 0x71 /* q */ => { + self.consume('q'); + if !self.try_consume('{') { + return error("Invalid class set escape: expected {"); + } + let mut alternatives = Vec::new(); + let mut alternative = Vec::new(); + loop { + match self.peek() { + Some(0x7D /* } */) => { + self.consume('}'); + if !alternative.is_empty() { + alternatives.push(alternative.clone()); + alternative.clear(); + } + break; + } + Some(0x7C /* | */) => { + self.consume('|'); + if !alternative.is_empty() { + alternatives.push(alternative.clone()); + alternative.clear(); + } + } + Some(_) => { + alternative.push(self.consume_class_set_character()?); + } + None => { + return error("Unbalanced class set string disjunction"); + } + } + } + Ok(ClassStringDisjunction(ClassSetAlternativeStrings(alternatives))) + } + // CharacterClassEscape :: d + 0x64 /* d */ => { + self.consume('d'); + Ok(CharacterClassEscape(codepoints_from_class(CharacterClassType::Digits, true))) + } + // CharacterClassEscape :: D + 0x44 /* D */ => { + self.consume('D'); + Ok(CharacterClassEscape(codepoints_from_class(CharacterClassType::Digits, false))) + } + // CharacterClassEscape :: s + 0x73 /* s */ => { + self.consume('s'); + Ok(CharacterClassEscape(codepoints_from_class(CharacterClassType::Spaces, true))) + } + // CharacterClassEscape :: S + 0x53 /* S */ => { + self.consume('S'); + Ok(CharacterClassEscape(codepoints_from_class(CharacterClassType::Spaces, false))) + } + // CharacterClassEscape :: w + 0x77 /* w */ => { + self.consume('w'); + Ok(CharacterClassEscape(codepoints_from_class(CharacterClassType::Words, true))) + } + // CharacterClassEscape :: W + 0x57 /* W */ => { + self.consume('W'); + Ok(CharacterClassEscape(codepoints_from_class(CharacterClassType::Words, false))) + } + // CharacterClassEscape :: [+UnicodeMode] p{ UnicodePropertyValueExpression } + 0x70 /* p */ => { + self.consume('p'); + match self.try_consume_unicode_property_escape()? { + PropertyEscapeKind::CharacterClass(intervals) => { + Ok(CharacterClassEscape(CodePointSet::from_sorted_disjoint_intervals( + intervals.to_vec(), + ))) + } + PropertyEscapeKind::StringSet(_) if negate_set => error("Invalid character escape"), + PropertyEscapeKind::StringSet(strings) => { + Ok(ClassStringDisjunction(ClassSetAlternativeStrings(strings.iter().map(|s| s.to_vec()).collect()))) + } + } + } + // CharacterClassEscape :: [+UnicodeMode] P{ UnicodePropertyValueExpression } + 0x50 /* P */ => { + self.consume('P'); + match self.try_consume_unicode_property_escape()? { + PropertyEscapeKind::CharacterClass(s) => { + Ok(CharacterClassEscape(CodePointSet::from_sorted_disjoint_intervals( + s.to_vec(), + ).inverted())) + } + PropertyEscapeKind::StringSet(_) => error("Invalid character escape"), + } + } + // ClassSetCharacter:: \b + 0x62 /* b */ => { + Ok(ClassSetCharacter(self.consume(cp))) + } + // ClassSetCharacter:: \ ClassSetReservedPunctuator + _ if Self::is_class_set_reserved_punctuator(cp) => Ok(ClassSetCharacter(self.consume(cp))), + // ClassSetCharacter:: \ CharacterEscape[+UnicodeMode] + _ => Ok(ClassSetCharacter(self.consume_character_escape()?)) + } + } + // ClassSetOperand :: ClassSetCharacter + // ClassSetRange :: ClassSetCharacter + _ => Ok(ClassSetCharacter(self.consume_class_set_character()?)), + } + } + + // ClassSetCharacter + fn consume_class_set_character(&mut self) -> Result { + let Some(cp) = self.next() else { + return error("Incomplete class set character"); + }; + match cp { + 0x5C /* \ */ => { + let Some(cp) = self.peek() else { + return error("Incomplete class set escape"); + }; + match cp { + // \b + 0x62 /* b */ => { + Ok(self.consume(cp)) + } + // \ ClassSetReservedPunctuator + _ if Self::is_class_set_reserved_punctuator(cp) => Ok(self.consume(cp)), + // \ CharacterEscape[+UnicodeMode] + _ => Ok(self.consume_character_escape()?) + } + } + // [lookahead ∉ ClassSetReservedDoublePunctuator] SourceCharacter but not ClassSetSyntaxCharacter + 0x28 /* ( */ | 0x29 /* ) */ | 0x7B /* { */ | 0x7D /* } */ | 0x2F /* / */ + | 0x2D /* - */ | 0x7C /* | */ => error("Invalid class set character"), + _ => { + if Self::is_class_set_reserved_double_punctuator(cp) + && let Some(cp) = self.peek() + && Self::is_class_set_reserved_double_punctuator(cp) { + return error("Invalid class set character"); + } + Ok(cp) + } + } + } + + // ClassSetReservedPunctuator + fn is_class_set_reserved_punctuator(cp: u32) -> bool { + match cp { + 0x26 /* & */ | 0x2D /* - */ | 0x21 /* ! */ | 0x23 /* # */ | 0x25 /* % */ + | 0x2C /* , */ | 0x3A /* : */ | 0x3B /* ; */ | 0x3C /* < */ | 0x3D /* = */ + | 0x3E /* > */ | 0x40 /* @ */ | 0x60 /* ` */ | 0x7E /* ~ */ => true, + _ => false, + } + } + + fn is_class_set_reserved_double_punctuator(cp: u32) -> bool { + match cp { + 0x26 /* & */ | 0x21 /* ! */ | 0x23 /* # */ | 0x24 /* $ */ | 0x25 /* % */ + | 0x2A /* * */ | 0x2B /* + */ | 0x2C /* , */ | 0x2E /* . */ | 0x3A /* : */ + | 0x3B /* ; */ | 0x3C /* < */ | 0x3D /* = */ | 0x3E /* > */ | 0x3F /* ? */ + | 0x40 /* @ */ | 0x5E /* ^ */ | 0x60 /* ` */ | 0x7E /* ~ */ => true, + _ => false, + } + } + + fn try_consume_quantifier(&mut self) -> Result, Error> { + if let Some(mut quant) = self.try_consume_quantifier_prefix()? { + quant.greedy = !self.try_consume('?'); + Ok(Some(quant)) + } else { + Ok(None) + } + } + + fn try_consume_quantifier_prefix(&mut self) -> Result, Error> { + let nc = self.peek(); + if nc.is_none() { + return Ok(None); + } + let c = nc.unwrap(); + match char::from_u32(c) { + Some('+') => { + self.consume('+'); + Ok(Some(ir::Quantifier { + min: 1, + max: None, + greedy: true, + })) + } + Some('*') => { + self.consume('*'); + Ok(Some(ir::Quantifier { + min: 0, + max: None, + greedy: true, + })) + } + Some('?') => { + self.consume('?'); + Ok(Some(ir::Quantifier { + min: 0, + max: Some(1), + greedy: true, + })) + } + Some('{') => { + if let Some(quantifier) = self.try_consume_braced_quantifier() { + Ok(Some(quantifier)) + } else if self.flags.unicode { + // if there was a brace '{' that doesn't parse into a valid quantifier, + // it's not valid with the unicode flag + error("Invalid quantifier") + } else { + Ok(None) + } + } + _ => Ok(None), + } + } + + fn try_consume_braced_quantifier(&mut self) -> Option { + // if parsed input is actually invalid, keep the previous one for rollback + let pre_input = self.input.clone(); + self.consume('{'); + let optmin = self.try_consume_decimal_integer_literal(); + let Some(optmin) = optmin else { + // not a valid quantifier, rollback consumption + self.input = pre_input; + return None; + }; + let mut quant = ir::Quantifier { + min: optmin, + max: Some(optmin), + greedy: true, + }; + if self.try_consume(',') { + let max = self.try_consume_decimal_integer_literal(); + // Either like {3,4} in which case we want to set the max; + // or like {3,} in which case the max should be None to indicate unbounded. + quant.max = max; + } else { + // Like {3}. + } + if !self.try_consume('}') { + // not a valid quantifier, rollback consumption + self.input = pre_input; + return None; + } + Some(quant) + } + + /// ES6 11.8.3 DecimalIntegerLiteral. + /// If the value would overflow, usize::MAX is returned. + /// All decimal digits are consumed regardless. + fn try_consume_decimal_integer_literal(&mut self) -> Option { + let mut result: usize = 0; + let mut char_count = 0; + while let Some(c) = self.peek() { + if let Some(digit) = char::from_u32(c).and_then(|c| char::to_digit(c, 10)) { + self.consume(c); + char_count += 1; + result = result.saturating_mul(10); + result = result.saturating_add(digit as usize); + } else { + break; + } + } + if char_count > 0 { Some(result) } else { None } + } + + fn consume_lookaround_assertion( + &mut self, + params: LookaroundParams, + ) -> Result { + let start_group = self.group_count; + let contents = self.consume_disjunction()?; + let end_group = self.group_count; + Ok(ir::Node::LookaroundAssertion { + negate: params.negate, + backwards: params.backwards, + start_group, + end_group, + contents: Box::new(contents), + }) + } + + fn consume_character_escape(&mut self) -> Result { + let c = self.next().expect("Should have a character"); + let ch = to_char_sat(c); + match ch { + // CharacterEscape :: ControlEscape :: f + 'f' => Ok(0xC), + // CharacterEscape :: ControlEscape :: n + 'n' => Ok(0xA), + // CharacterEscape :: ControlEscape :: r + 'r' => Ok(0xD), + // CharacterEscape :: ControlEscape :: t + 't' => Ok(0x9), + // CharacterEscape :: ControlEscape :: v + 'v' => Ok(0xB), + // CharacterEscape :: c AsciiLetter + 'c' => { + if let Some(nc) = self.next().and_then(char::from_u32) + && (nc.is_ascii_lowercase() || nc.is_ascii_uppercase()) + { + return Ok((nc as u32) % 32); + } + error("Invalid character escape") + } + // CharacterEscape :: 0 [lookahead ∉ DecimalDigit] + '0' if self + .peek() + .and_then(char::from_u32) + .map(|c: char| c.is_ascii_digit()) + != Some(true) => + { + Ok(0x0) + } + // CharacterEscape :: HexEscapeSequence :: x HexDigit HexDigit + 'x' => { + let hex_to_digit = |c: char| c.to_digit(16); + let x1 = self.next().and_then(char::from_u32).and_then(hex_to_digit); + let x2 = self.next().and_then(char::from_u32).and_then(hex_to_digit); + match (x1, x2) { + (Some(x1), Some(x2)) => Ok(x1 * 16 + x2), + // CharacterEscape :: IdentityEscape :: SourceCharacterIdentityEscape + _ if !self.flags.unicode => Ok(c), + _ => error("Invalid character escape"), + } + } + // CharacterEscape :: RegExpUnicodeEscapeSequence + 'u' => { + if let Some(c) = self.try_escape_unicode_sequence() { + Ok(c) + } else if !self.flags.unicode { + // CharacterEscape :: IdentityEscape :: SourceCharacterIdentityEscape + Ok(c) + } else { + error("Invalid unicode escape") + } + } + // CharacterEscape :: [~UnicodeMode] LegacyOctalEscapeSequence + '0'..='7' if !self.flags.unicode => { + let Some(c1) = self.peek() else { + return Ok(c - '0' as u32); + }; + let ch1 = to_char_sat(c1); + + match ch { + // 0 [lookahead ∈ { 8, 9 }] + '0' if ('8'..='9').contains(&ch1) => Ok(0x0), + // NonZeroOctalDigit [lookahead ∉ OctalDigit] + _ if !('0'..='7').contains(&ch1) => Ok(c - '0' as u32), + // FourToSeven OctalDigit + '4'..='7' => { + self.consume(c1); + Ok((c - '0' as u32) * 8 + c1 - '0' as u32) + } + // ZeroToThree OctalDigit [lookahead ∉ OctalDigit] + // ZeroToThree OctalDigit OctalDigit + '0'..='3' => { + self.consume(c1); + if self.peek().map(|c2| ('0'..='7').contains(&to_char_sat(c2))) + == Some(true) + { + let c2 = self.next().expect("char was not next"); + Ok((c - '0' as u32) * 64 + (c1 - '0' as u32) * 8 + c2 - '0' as u32) + } else { + Ok((c - '0' as u32) * 8 + c1 - '0' as u32) + } + } + _ => unreachable!(), + } + } + // CharacterEscape :: IdentityEscape :: [+UnicodeMode] SyntaxCharacter + // CharacterEscape :: IdentityEscape :: [+UnicodeMode] / + '^' | '$' | '\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' + | '/' => Ok(c), + // CharacterEscape :: IdentityEscape :: SourceCharacterIdentityEscape + _ if !self.flags.unicode => Ok(c), + _ => error("Invalid character escape"), + } + } + + // AtomEscape + fn consume_atom_escape(&mut self) -> Result { + let Some(c) = self.peek() else { + return error("Incomplete escape"); + }; + match to_char_sat(c) { + 'd' | 'D' => { + self.consume(c); + Ok(make_bracket_class( + CharacterClassType::Digits, + c == 'd' as u32, + self.flags.icase, + )) + } + + 's' | 'S' => { + self.consume(c); + Ok(make_bracket_class( + CharacterClassType::Spaces, + c == 's' as u32, + self.flags.icase, + )) + } + + 'w' | 'W' => { + self.consume(c); + Ok(make_bracket_class( + CharacterClassType::Words, + c == 'w' as u32, + self.flags.icase, + )) + } + + // ClassEscape :: CharacterClassEscape :: [+UnicodeMode] p{ UnicodePropertyValueExpression } + // ClassEscape :: CharacterClassEscape :: [+UnicodeMode] P{ UnicodePropertyValueExpression } + 'p' | 'P' if self.flags.unicode || self.flags.unicode_sets => { + self.consume(c); + let negate = c == 'P' as u32; + let property_escape = self.try_consume_unicode_property_escape()?; + match property_escape { + PropertyEscapeKind::CharacterClass(s) => { + Ok(ir::Node::Bracket(BracketContents { + invert: negate, + cps: CodePointSet::from_sorted_disjoint_intervals(s.to_vec()), + })) + } + PropertyEscapeKind::StringSet(_) if negate => error("Invalid character escape"), + PropertyEscapeKind::StringSet(strings) => Ok(make_alt( + strings + .iter() + .map(|s| { + ir::Node::Cat( + s.iter() + .map(|c| ir::Node::Char { + c: *c, + icase: self.flags.icase, + }) + .collect(), + ) + }) + .collect(), + )), + } + } + + // [+UnicodeMode] DecimalEscape + // Note: This is a backreference. + '1'..='9' if self.flags.unicode => { + let group = self.try_consume_decimal_integer_literal().unwrap(); + if group <= self.group_count_max as usize { + Ok(ir::Node::BackRef(group as u32)) + } else { + error("Invalid character escape") + } + } + + // [~UnicodeMode] DecimalEscape but only if the CapturingGroupNumber of DecimalEscape + // is ≤ CountLeftCapturingParensWithin(the Pattern containing DecimalEscape) + // Note: This could be either a backreference, a legacy octal escape or an identity escape. + '1'..='9' => { + let input = self.input.clone(); + let group = self.try_consume_decimal_integer_literal().unwrap(); + + if group <= self.group_count_max as usize { + Ok(ir::Node::BackRef(group as u32)) + } else { + self.input = input; + let c = self.consume_character_escape()?; + Ok(ir::Node::Char { + c: self.fold_if_icase(c), + icase: self.flags.icase, + }) + } + } + + // [+NamedCaptureGroups] k GroupName + 'k' if self.flags.unicode || !self.named_group_indices.is_empty() => { + // The sequence `\k` must be the start of a backreference to a named capture group. + // Note multiple capture groups may have the same name; we must map all of them to their indices. + self.consume('k'); + // Must have a valid group name. + let Some(group_name) = self.try_consume_named_capture_group_name() else { + return error("Invalid named backreference syntax"); + }; + // The group name must be the name of a previously defined capture group. + let Some(group_indices) = self.named_group_indices.get(&group_name) else { + return error(format!( + "Backreference to invalid named capture group: {}", + &group_name + )); + }; + // Note backreferences are 1-based. + let node = match group_indices.len() { + 0 => unreachable!("Should not have empty indices for group name"), + 1 => { + // Common case of a backref matching a single group. + ir::Node::BackRef(group_indices[0] + 1) + } + _ => { + // Unusual case of multiple groups sharing a name: the backref should try each in turn. + // Lower to alternations of backreferences. Reverse to keep it right-associative: a | (b | (c | d))... + let backrefs = group_indices + .iter() + .rev() + .map(|group_index| ir::Node::BackRef(*group_index + 1)); + backrefs + .reduce(|right, left| ir::Node::Alt(Box::new(left), Box::new(right))) + .unwrap() + } + }; + Ok(node) + } + + // [~NamedCaptureGroups] k GroupName + 'k' => { + self.consume('k'); + Ok(ir::Node::Char { + c: self.fold_if_icase(c), + icase: self.flags.icase, + }) + } + + _ => { + let c = self.consume_character_escape()?; + Ok(ir::Node::Char { + c: self.fold_if_icase(c), + icase: self.flags.icase, + }) + } + } + } + + #[allow(clippy::branches_sharing_code)] + fn try_escape_unicode_sequence(&mut self) -> Option { + let mut orig_input = self.input.clone(); + + // Support \u{X..X} (Unicode CodePoint) + if self.try_consume('{') { + let mut s = String::new(); + loop { + match self.next().and_then(char::from_u32) { + Some('}') => break, + Some(c) => s.push(c), + None => { + // Surrogates not supported in code point escapes. + self.input = orig_input; + return None; + } + } + } + + match u32::from_str_radix(&s, 16) { + Ok(u) => { + if u > 0x10_FFFF { + self.input = orig_input; + None + } else { + Some(u) + } + } + _ => { + self.input = orig_input; + None + } + } + } else { + // Hex4Digits + let mut s = String::new(); + for _ in 0..4 { + if let Some(c) = self.next().and_then(char::from_u32) { + s.push(c); + } else { + // Surrogates are not hex digits. + self.input = orig_input; + return None; + } + } + match u16::from_str_radix(&s, 16) { + Ok(u) => { + if (0xD800..=0xDBFF).contains(&u) { + // Found a high surrogate. Try to parse a low surrogate next + // to see if we can rebuild the original `char` + + if !self.try_consume_str("\\u") { + return Some(u as u32); + } + orig_input = self.input.clone(); + + // A poor man's try block to handle the backtracking + // in a single place instead of every time we want to return. + // This allows us to use `?` within the inner block without returning + // from the entire parent function. + let result = (|| { + let mut s = String::new(); + for _ in 0..4 { + let c = self.next().and_then(char::from_u32)?; + s.push(c); + } + + let uu = u16::from_str_radix(&s, 16).ok()?; + let ch = char::decode_utf16([u, uu]).next()?.ok()?; + Some(u32::from(ch)) + })(); + + result.or_else(|| { + self.input = orig_input; + Some(u as u32) + }) + } else { + // If `u` is not a surrogate or is a low surrogate we can directly return it, + // since all paired low surrogates should have been handled above. + Some(u as u32) + } + } + _ => { + self.input = orig_input; + None + } + } + } + } + + fn try_consume_named_capture_group_name(&mut self) -> Option { + if !self.try_consume('<') { + return None; + } + + let orig_input = self.input.clone(); + let mut group_name = String::new(); + + if let Some(mut c) = self.next().and_then(char::from_u32) { + if c == '\\' && self.try_consume('u') { + if let Some(escaped) = self.try_escape_unicode_sequence().and_then(char::from_u32) { + c = escaped; + } else { + self.input = orig_input; + return None; + } + } + + if interval_contains(id_start_ranges(), c.into()) || c == '$' || c == '_' { + group_name.push(c); + } else { + self.input = orig_input; + return None; + } + } else { + self.input = orig_input; + return None; + } + + loop { + if let Some(mut c) = self.next().and_then(char::from_u32) { + if c == '\\' && self.try_consume('u') { + if let Some(escaped) = + self.try_escape_unicode_sequence().and_then(char::from_u32) + { + c = escaped; + } else { + self.input = orig_input; + return None; + } + } + + if c == '>' { + break; + } + + if interval_contains(id_continue_ranges(), c.into()) || c == '$' || c == '_' || c == '\u{200C}' /* */ || c == '\u{200D}' + /* */ + { + group_name.push(c); + } else { + self.input = orig_input; + return None; + } + } else { + self.input = orig_input; + return None; + } + } + + Some(group_name) + } + + // Quickly parse all capture groups. + // Per TC39 proposal, duplicate named groups are allowed in different alternatives. + fn parse_capture_groups(&mut self) -> Result<(), Error> { + let orig_input = self.input.clone(); + + // Pass 1: Collect all named capture groups with their alternative paths + let named_group_locations = self.collect_named_group_locations()?; + + // Pass 2: Check for conflicts (duplicates in the same alternative path) + self.check_duplicate_conflicts(&named_group_locations)?; + + self.input = orig_input; + + Ok(()) + } + + /// Pass 1: Collect all named capture groups and record which alternative path each appears in. + fn collect_named_group_locations( + &mut self, + ) -> Result>, Error> { + // Track parenthesis depth and alternative index at each depth + let mut paren_depth: usize = 0; + // Map from depth to current alternative index at that depth + let mut alt_indices: HashMap = HashMap::new(); + alt_indices.insert(0, 0); + + // Map from group name to all alternative paths where it appears + let mut named_group_locations: HashMap> = HashMap::new(); + + loop { + match self.next().map(to_char_sat) { + Some('\\') => { + self.next(); + continue; + } + Some('[') => loop { + match self.next().map(to_char_sat) { + Some('\\') => { + self.next(); + continue; + } + Some(']') => break, + Some(_) => continue, + None => break, + } + }, + Some('(') => { + // Determine whether we're a capturing group, and optionally the name. + let is_capturing; + let group_name; + if self.try_consume_str("?") { + group_name = self.try_consume_named_capture_group_name(); + is_capturing = group_name.is_some(); // (?:, (?=, (?!, etc. are non-capturing. + } else { + is_capturing = true; + group_name = None; // Unnamed capture group + } + + if let Some(name) = group_name { + // Build current alternative path from depth 0 to current depth. + let mut segments = Vec::new(); + for d in 0..=paren_depth { + segments.push((d, *alt_indices.get(&d).unwrap_or(&0))); + } + + // Record this location. + named_group_locations + .entry(name.clone()) + .or_default() + .push(AlternativePath { segments }); + + // Store all occurrences in named_group_indices. + self.named_group_indices + .entry(name) + .or_default() + .push(self.group_count_max); + } + + if is_capturing { + self.group_count_max = + if self.group_count_max + 1 > MAX_CAPTURE_GROUPS as u32 { + MAX_CAPTURE_GROUPS as u32 + } else { + self.group_count_max + 1 + }; + } + + // Entering a new group. + paren_depth += 1; + alt_indices.insert(paren_depth, 0); + } + Some(')') => { + // Exiting a group + if paren_depth > 0 { + alt_indices.remove(&paren_depth); + paren_depth -= 1; + } + } + Some('|') => { + // Moving to next alternative at current depth + *alt_indices.entry(paren_depth).or_insert(0) += 1; + } + Some(_) => continue, + None => break, + } + } + + Ok(named_group_locations) + } + + /// Pass 2: Check that named groups with the same name don't conflict. + /// Groups conflict if they appear in the same alternative path. + /// Per TC39 proposal, `/(?x)|(?y)/` is valid (different alternatives), + /// but `/(?x)(?y)/` is invalid (same alternative). + fn check_duplicate_conflicts( + &self, + named_group_locations: &HashMap>, + ) -> Result<(), Error> { + for paths in named_group_locations.values() { + // Check each pair of paths for this group name + for i in 0..paths.len() { + for j in (i + 1)..paths.len() { + if paths[i].conflicts_with(&paths[j]) { + return error("Duplicate capture group name"); + } + } + } + } + Ok(()) + } + + fn try_consume_unicode_property_escape(&mut self) -> Result { + if !self.try_consume('{') { + return error("Invalid character at property escape start"); + } + + let mut buffer = String::new(); + let mut name = None; + + while let Some(c) = self.peek().and_then(char::from_u32) { + match c { + '}' => { + self.consume(c); + let Some(value) = + unicode_property_from_str(&buffer, name, self.flags.unicode_sets) + else { + break; + }; + return Ok(value); + } + '=' if name.is_none() => { + self.consume(c); + let Some(n) = unicode_property_name_from_str(&buffer) else { + break; + }; + name = Some(n); + buffer.clear(); + } + c if c.is_ascii_alphanumeric() || c == '_' => { + self.consume(c); + buffer.push(c); + } + _ => break, + } + } + + error("Invalid property name") + } + + fn finalize(&self, mut re: ir::Regex) -> Result { + debug_assert!(self.loop_count <= MAX_LOOPS as u32); + debug_assert!(self.group_count as usize <= MAX_CAPTURE_GROUPS); + if self.has_lookbehind { + ir::walk_mut( + false, + re.flags.unicode, + &mut re.node, + &mut ir::Node::reverse_cats, + ); + } + Ok(re) + } +} + +/// Try parsing a given pattern. +/// Return the resulting IR regex, or an error. +pub fn try_parse(pattern: I, flags: api::Flags) -> Result +where + I: Iterator + Clone, +{ + let mut p = Parser { + input: pattern.peekable(), + flags, + loop_count: 0, + group_count: 0, + named_group_indices: HashMap::new(), + group_count_max: 0, + has_lookbehind: false, + }; + p.try_parse() +} diff --git a/third_party/regress/src/pikevm.rs b/third_party/regress/src/pikevm.rs new file mode 100644 index 00000000..84ce89c3 --- /dev/null +++ b/third_party/regress/src/pikevm.rs @@ -0,0 +1,501 @@ +//! PikeVM regex execution engine + +use crate::api::Match; +use crate::bytesearch::charset_contains; +use crate::cursor; +use crate::cursor::{Backward, Direction, Forward}; +use crate::exec; +use crate::indexing::{AsciiInput, ElementType, InputIndexer, Utf8Input}; +use crate::insn::{CompiledRegex, Insn, LoopFields, StartPredicate}; +use crate::matchers; +use crate::matchers::CharProperties; +use crate::position::PositionType; +use crate::scm; +use crate::scm::SingleCharMatcher; +use crate::types::{GroupData, LoopData}; +use crate::util::DebugCheckIndex; +#[cfg(not(feature = "std"))] +use alloc::{string::String, vec::Vec}; +use core::ops::Range; + +#[derive(Debug, Clone)] +struct State { + /// Position in the input string. + pos: Position, + + /// Offset in the bytecode. + ip: usize, + + /// Loop datas. + loops: Vec>, + + /// Group datas. + groups: Vec>, +} + +enum StateMatch { + Fail, + Continue, + Split(State), + Complete, +} + +fn run_loop( + s: &mut State, + lf: &LoopFields, + is_initial_entry: bool, +) -> StateMatch { + debug_assert!(lf.max_iters >= lf.min_iters); + let ld = &mut s.loops[lf.loop_id as usize]; + let exit = lf.exit as usize; + let skip_ok; + let enter_ok; + if is_initial_entry { + // Entering the loop for the "first" time. + ld.iters = 0; + enter_ok = lf.max_iters > 0; + skip_ok = lf.min_iters == 0; + } else { + // Note that iters is the number of complete iterations. + ld.iters += 1; + // We can enter the loop if we have iterated less than the maximum number of + // times. + enter_ok = ld.iters < lf.max_iters; + + // We can skip the loop if we have iterated at least the minimum number of + // times. + skip_ok = ld.iters >= lf.min_iters; + + // Check if this iteration was beyond the minimum number of times, and our entry + // position is the same as last time (ES6 21.2.2.5.1 note 4). + // If so, we matched the empty string and we stop. + if ld.iters > lf.min_iters && ld.entry == s.pos { + return StateMatch::Fail; + } + } + // Set up our fields as if we are going to enter the loop. + ld.entry = s.pos; + s.ip += 1; + + if !enter_ok && !skip_ok { + StateMatch::Fail + } else if !enter_ok { + s.ip = exit; + StateMatch::Continue + } else if !skip_ok { + StateMatch::Continue + } else { + debug_assert!(enter_ok && skip_ok); + // We need to split our state. + let mut newstate = s.clone(); + let exit_state = if lf.greedy { s } else { &mut newstate }; + exit_state.ip = exit; + StateMatch::Split(newstate) + } +} + +fn try_match_state( + re: &CompiledRegex, + input: &Input, + s: &mut State, + dir: Dir, +) -> StateMatch { + macro_rules! nextinsn_or_fail { + ($e:expr) => { + if $e { + s.ip += 1; + StateMatch::Continue + } else { + StateMatch::Fail + } + }; + } + match &re.insns[s.ip] { + Insn::Goal => StateMatch::Complete, + Insn::JustFail => StateMatch::Fail, + &Insn::Char(c) => match cursor::next(input, dir, &mut s.pos) { + Some(c2) => nextinsn_or_fail!(c == c2.as_u32()), + _ => StateMatch::Fail, + }, + &Insn::CharICase(c) => match cursor::next(input, dir, &mut s.pos) { + Some(c2) => { + nextinsn_or_fail!(c == c2.as_u32() || input.fold(c2).as_u32() == c) + } + _ => StateMatch::Fail, + }, + + Insn::CharSet(v) => match cursor::next(input, dir, &mut s.pos) { + Some(c) => nextinsn_or_fail!(charset_contains(v, c.as_u32())), + _ => StateMatch::Fail, + }, + + Insn::ByteSeq1(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq2(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq3(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq4(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq5(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq6(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq7(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq8(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq9(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq10(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq11(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq12(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq13(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq14(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq15(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + Insn::ByteSeq16(v) => nextinsn_or_fail!(cursor::try_match_lit(input, dir, &mut s.pos, v)), + + Insn::StartOfLine { multiline } => { + let multiline = *multiline; + let matches = match input.peek_left(s.pos) { + None => true, + Some(c) if multiline && Input::CharProps::is_line_terminator(c) => true, + _ => false, + }; + nextinsn_or_fail!(matches) + } + + Insn::EndOfLine { multiline } => { + let multiline = *multiline; + let matches = match input.peek_right(s.pos) { + None => true, // we're at the right of the string + Some(c) if multiline && Input::CharProps::is_line_terminator(c) => true, + _ => false, + }; + nextinsn_or_fail!(matches) + } + + Insn::MatchAny => match cursor::next(input, dir, &mut s.pos) { + Some(_) => nextinsn_or_fail!(true), + _ => StateMatch::Fail, + }, + + Insn::MatchAnyExceptLineTerminator => match cursor::next(input, dir, &mut s.pos) { + Some(c2) => nextinsn_or_fail!(!Input::CharProps::is_line_terminator(c2)), + _ => StateMatch::Fail, + }, + + &Insn::Jump { target } => { + s.ip = target as usize; + StateMatch::Continue + } + + &Insn::Alt { secondary } => { + let mut left = s.clone(); + left.ip += 1; + s.ip = secondary as usize; + StateMatch::Split(left) + } + + &Insn::BeginCaptureGroup(group_idx) => { + let group = &mut s.groups[group_idx as usize]; + if Dir::FORWARD { + core::debug_assert!(!group.start_matched(), "Group should not have been entered"); + group.start = Some(s.pos); + } else { + core::debug_assert!(!group.end_matched(), "Group should not have been entered"); + group.end = Some(s.pos); + } + nextinsn_or_fail!(true) + } + + &Insn::EndCaptureGroup(group_idx) => { + let group = &mut s.groups[group_idx as usize]; + if Dir::FORWARD { + core::debug_assert!(group.start_matched(), "Group should have been entered"); + group.end = Some(s.pos); + } else { + core::debug_assert!(group.end_matched(), "Group should have been exited"); + group.start = Some(s.pos); + } + core::debug_assert!( + group.end >= group.start, + "Exit pos should be after start pos" + ); + nextinsn_or_fail!(true) + } + + &Insn::ResetCaptureGroup(group_idx) => { + s.groups[group_idx as usize].reset(); + nextinsn_or_fail!(true) + } + + &Insn::BackRef(group_idx) => { + let matched; + let group = &mut s.groups[group_idx as usize]; + if let Some(orig_range) = group.as_range() { + if re.flags.icase { + matched = matchers::backref_icase(input, dir, orig_range, &mut s.pos); + } else { + matched = matchers::backref(input, dir, orig_range, &mut s.pos) + } + } else { + // This group has not been exited, and therefore the match succeeds + // (ES6 21.2.2.9). + matched = true; + } + nextinsn_or_fail!(matched) + } + + &Insn::Lookahead { + negate, + start_group: _, + end_group: _, + continuation, + } => { + // Enter into the lookaround's instruction stream. + s.ip += 1; + let saved_pos = s.pos; + let attempt_succeeded = + MatchAttempter::::new(re).try_at_pos(*input, s, Forward::new()); + let matched = attempt_succeeded != negate; + if matched { + s.ip = continuation as usize; + s.pos = saved_pos; + StateMatch::Continue + } else { + StateMatch::Fail + } + } + + &Insn::Lookbehind { + negate, + start_group: _, + end_group: _, + continuation, + } => { + // Enter into the lookaround's instruction stream. + s.ip += 1; + let saved_pos = s.pos; + let attempt_succeeded = MatchAttempter::new(re).try_at_pos(*input, s, Backward::new()); + let matched = attempt_succeeded != negate; + if matched { + s.ip = continuation as usize; + s.pos = saved_pos; + StateMatch::Continue + } else { + StateMatch::Fail + } + } + Insn::EnterLoop(lf) => run_loop(s, lf, true), + &Insn::LoopAgain { begin } => { + s.ip = begin as usize; + match re.insns.iat(s.ip) { + Insn::EnterLoop(lf) => run_loop(s, lf, false), + _ => panic!("LoopAgain does not point at EnterLoop"), + } + } + Insn::Loop1CharBody { .. } => panic!("Loop1CharBody unimplemented for pikevm"), + &Insn::Bracket(idx) => match cursor::next(input, dir, &mut s.pos) { + Some(c) => nextinsn_or_fail!(Input::CharProps::bracket(&re.brackets[idx], c)), + _ => StateMatch::Fail, + }, + + Insn::AsciiBracket(bytes) => { + nextinsn_or_fail!(scm::MatchByteSet { bytes }.matches(input, dir, &mut s.pos)) + } + &Insn::ByteSet2(bytes) => { + nextinsn_or_fail!(scm::MatchByteArraySet(bytes).matches(input, dir, &mut s.pos)) + } + &Insn::ByteSet3(bytes) => { + nextinsn_or_fail!(scm::MatchByteArraySet(bytes).matches(input, dir, &mut s.pos)) + } + &Insn::ByteSet4(bytes) => { + nextinsn_or_fail!(scm::MatchByteArraySet(bytes).matches(input, dir, &mut s.pos)) + } + + &Insn::WordBoundary { invert } => { + let prev_wordchar = input + .peek_left(s.pos) + .is_some_and(Input::CharProps::is_word_char); + let curr_wordchar = input + .peek_right(s.pos) + .is_some_and(Input::CharProps::is_word_char); + let is_boundary = prev_wordchar != curr_wordchar; + nextinsn_or_fail!(is_boundary != invert) + } + + &Insn::WordBoundaryUnicodeICase { invert } => { + let prev_wordchar = input + .peek_left(s.pos) + .is_some_and(Input::CharProps::is_word_char_unicode_icase); + let curr_wordchar = input + .peek_right(s.pos) + .is_some_and(Input::CharProps::is_word_char_unicode_icase); + let is_boundary = prev_wordchar != curr_wordchar; + nextinsn_or_fail!(is_boundary != invert) + } + } +} + +fn successful_match( + input: Input, + start: Input::Position, + state: &State, + group_names: Box<[Box]>, +) -> Match { + let group_to_offset = |mr: &GroupData| -> Option> { + mr.as_range().map(|r| Range { + start: input.pos_to_offset(r.start), + end: input.pos_to_offset(r.end), + }) + }; + let captures = state.groups.iter().map(group_to_offset).collect(); + Match { + range: input.pos_to_offset(start)..input.pos_to_offset(state.pos), + captures, + group_names, + } +} + +#[derive(Debug)] +struct MatchAttempter<'a, Input: InputIndexer> { + states: Vec>, + re: &'a CompiledRegex, +} + +impl<'a, Input: InputIndexer> MatchAttempter<'a, Input> { + fn new(re: &'a CompiledRegex) -> Self { + Self { + states: Vec::new(), + re, + } + } + + fn try_at_pos( + &mut self, + input: Input, + init_state: &mut State, + dir: Dir, + ) -> bool { + debug_assert!(self.states.is_empty(), "Should be no states"); + self.states.push(init_state.clone()); + while !self.states.is_empty() { + let s = self.states.last_mut().unwrap(); + match try_match_state(self.re, &input, s, dir) { + StateMatch::Fail => { + self.states.pop(); + } + StateMatch::Continue => {} + StateMatch::Complete => { + // Give the successful state to the caller. + core::mem::swap(init_state, s); + self.states.clear(); + return true; + } + StateMatch::Split(newstate) => self.states.push(newstate), + } + } + false + } +} + +#[derive(Debug)] +pub struct PikeVMExecutor<'r, Input: InputIndexer> { + input: Input, + matcher: MatchAttempter<'r, Input>, +} + +impl<'r, 't> exec::Executor<'r, 't> for PikeVMExecutor<'r, Utf8Input<'t>> { + type AsAscii = PikeVMExecutor<'r, AsciiInput<'t>>; + + fn new(re: &'r CompiledRegex, text: &'t str) -> Self { + let input = Utf8Input::new(text, re.flags.unicode); + Self { + input, + matcher: MatchAttempter::new(re), + } + } +} + +impl<'r, 't> exec::Executor<'r, 't> for PikeVMExecutor<'r, AsciiInput<'t>> { + type AsAscii = PikeVMExecutor<'r, AsciiInput<'t>>; + + fn new(re: &'r CompiledRegex, text: &'t str) -> Self { + let input = AsciiInput::new(text, re.flags.unicode); + Self { + input, + matcher: MatchAttempter::new(re), + } + } +} + +impl exec::MatchProducer for PikeVMExecutor<'_, Input> { + type Position = Input::Position; + + fn initial_position(&self, offset: usize) -> Option { + self.input.try_move_right(self.input.left_end(), offset) + } + + fn next_match( + &mut self, + pos: Self::Position, + next_start: &mut Option, + ) -> Option { + let re = self.matcher.re; + + // Check if this is an anchored regex - if so, only try matching at the current position + if matches!(re.start_pred, StartPredicate::StartAnchored) { + let mut state = State { + pos, + ip: 0, + loops: vec![LoopData::new(pos); re.loops as usize], + groups: vec![GroupData::new(); re.groups as usize], + }; + if self + .matcher + .try_at_pos(self.input, &mut state, Forward::new()) + { + let end = state.pos; + if end != pos { + *next_start = Some(end) + } else { + *next_start = self.input.next_right_pos(end) + } + return Some(successful_match( + self.input, + pos, + &state, + re.group_names.clone(), + )); + } + // Anchored regex failed to match at this position + return None; + } + + // Standard matching - try at each position + // Note the "initial" loop position is ignored. Use whatever is most convenient. + let mut state = State { + pos, + ip: 0, + loops: vec![LoopData::new(pos); re.loops as usize], + groups: vec![GroupData::new(); re.groups as usize], + }; + loop { + let start = state.pos; + if self + .matcher + .try_at_pos(self.input, &mut state, Forward::new()) + { + let end = state.pos; + if end != start { + *next_start = Some(end) + } else { + *next_start = self.input.next_right_pos(end) + } + return Some(successful_match( + self.input, + start, + &state, + re.group_names.clone(), + )); + } + match self.input.next_right_pos(start) { + Some(nextpos) => state.pos = nextpos, + None => break, + } + } + None + } +} diff --git a/third_party/regress/src/position.rs b/third_party/regress/src/position.rs new file mode 100644 index 00000000..f531466c --- /dev/null +++ b/third_party/regress/src/position.rs @@ -0,0 +1,185 @@ +use core::cmp::Eq; +use core::fmt; +use core::marker::PhantomData; +use core::ops; + +/// A trait which references a position in an input string. +/// The intent is that this may be satisfied via indexes or pointers. +/// Positions must be subtractable, producing usize; they also obey other "pointer arithmetic" ideas. +pub trait PositionType: + core::fmt::Debug + Copy + Clone + PartialEq + Eq + PartialOrd + Ord +where + Self: ops::Add, + Self: ops::Sub, + Self: ops::Sub, + Self: ops::AddAssign, + Self: ops::SubAssign, +{ +} + +/// Choose the preferred position type with this alias. +#[cfg(feature = "index-positions")] +pub type DefPosition<'a> = IndexPosition<'a>; + +#[cfg(not(feature = "index-positions"))] +pub type DefPosition<'a> = RefPosition<'a>; + +/// A simple index-based position. +/// It remembers the lifetime of the slice it is tied to. +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] +pub struct IndexPosition<'a>(usize, PhantomData<&'a ()>); + +impl<'a> fmt::Debug for IndexPosition<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IndexPosition").field(&self.0).finish() + } +} + +#[allow(dead_code)] +impl IndexPosition<'_> { + /// IndexPosition does not enforce its size. + #[inline(always)] + pub fn check_size() {} + + #[inline(always)] + pub fn new(pos: usize) -> Self { + Self(pos, PhantomData) + } +} + +impl ops::Add for IndexPosition<'_> { + type Output = Self; + + #[inline(always)] + fn add(self, rhs: usize) -> Self::Output { + debug_assert!(self.0 + rhs >= self.0, "Overflow"); + IndexPosition(self.0 + rhs, PhantomData) + } +} + +impl ops::AddAssign for IndexPosition<'_> { + #[inline(always)] + fn add_assign(&mut self, rhs: usize) { + *self = *self + rhs; + } +} + +impl ops::SubAssign for IndexPosition<'_> { + #[inline(always)] + fn sub_assign(&mut self, rhs: usize) { + *self = *self - rhs; + } +} + +impl<'a> ops::Sub> for IndexPosition<'a> { + type Output = usize; + + #[inline(always)] + fn sub(self, rhs: Self) -> Self::Output { + debug_assert!(self.0 >= rhs.0, "Underflow"); + self.0 - rhs.0 + } +} + +impl ops::Sub for IndexPosition<'_> { + type Output = Self; + + #[inline(always)] + fn sub(self, rhs: usize) -> Self::Output { + debug_assert!(self.0 >= rhs, "Underflow"); + IndexPosition(self.0 - rhs, PhantomData) + } +} + +impl PositionType for IndexPosition<'_> {} + +/// A reference position holds a reference to a byte and uses pointer arithmetic. +/// This must use raw pointers because it must be capable of representing the one-past-the-end value. +/// TODO: thread lifetimes through this. +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] +pub struct RefPosition<'a>(core::ptr::NonNull, PhantomData<&'a ()>); + +impl<'a> fmt::Debug for RefPosition<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let addr = self.0.as_ptr() as usize; + f.debug_tuple("RefPosition").field(&addr).finish() + } +} + +#[allow(dead_code)] +impl RefPosition<'_> { + /// The big idea of RefPosition is that `Option` becomes pointer-sized, by using nullptr as the None value. + /// Good candidate for const-panics when stabilized. + #[inline(always)] + pub fn check_size() { + if core::mem::size_of::>() > core::mem::size_of::<*const u8>() { + panic!("Option should be pointer sized") + } + } + + /// Access the underlying pointer. + #[inline(always)] + pub fn ptr(self) -> *const u8 { + self.0.as_ptr() + } + + /// Construct from a pointer, which must never be null. + #[inline(always)] + pub fn new(ptr: *const u8) -> Self { + debug_assert!(!ptr.is_null(), "Pointer cannot be null"); + // Annoyingly there's no *const NonNull. + let mutp = ptr as *mut u8; + let nonnullp = if cfg!(feature = "prohibit-unsafe") { + core::ptr::NonNull::new(mutp).expect("Pointer was null") + } else { + unsafe { core::ptr::NonNull::new_unchecked(mutp) } + }; + Self(nonnullp, PhantomData) + } +} + +impl PositionType for RefPosition<'_> {} + +impl ops::Add for RefPosition<'_> { + type Output = Self; + + #[inline(always)] + fn add(self, rhs: usize) -> Self::Output { + Self::new(unsafe { self.ptr().add(rhs) }) + } +} + +impl<'a> ops::Sub> for RefPosition<'a> { + type Output = usize; + + #[inline(always)] + fn sub(self, rhs: Self) -> Self::Output { + debug_assert!(self.0 >= rhs.0, "Underflow"); + // Note Rust has backwards naming here. The "origin" is self, not the param; the rhs is the offset value. + unsafe { self.ptr().offset_from(rhs.ptr()) as usize } + } +} + +impl ops::Sub for RefPosition<'_> { + type Output = Self; + + #[inline(always)] + fn sub(self, rhs: usize) -> Self::Output { + debug_assert!(self.ptr() as usize >= rhs, "Underflow"); + Self::new(unsafe { self.ptr().sub(rhs) }) + } +} + +impl ops::AddAssign for RefPosition<'_> { + #[inline(always)] + fn add_assign(&mut self, rhs: usize) { + *self = *self + rhs; + } +} + +impl ops::SubAssign for RefPosition<'_> { + #[inline(always)] + fn sub_assign(&mut self, rhs: usize) { + *self = *self - rhs; + } +} diff --git a/third_party/regress/src/scm.rs b/third_party/regress/src/scm.rs new file mode 100644 index 00000000..a00df671 --- /dev/null +++ b/third_party/regress/src/scm.rs @@ -0,0 +1,158 @@ +use crate::bytesearch::{ByteArraySet, ByteSet, SmallArraySet, charset_contains}; +use crate::cursor; +use crate::cursor::Direction; +use crate::indexing::{ElementType, InputIndexer}; +use crate::insn::MAX_CHAR_SET_LENGTH; +use crate::matchers::CharProperties; +use crate::types::BracketContents; + +/// A trait for things that match a single Element. +pub trait SingleCharMatcher { + /// \return whether we match the character at the given position, advancing + /// the position if so. On a false return, the position is unspecified. + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool; +} + +/// Insn::Char +pub struct Char { + pub c: Input::Element, +} +impl SingleCharMatcher for Char { + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + match cursor::next(input, dir, pos) { + Some(c2) => c2 == self.c, + _ => false, + } + } +} + +/// Insn::CharICase +pub struct CharICase { + pub c: Input::Element, +} +impl SingleCharMatcher for CharICase { + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + match cursor::next(input, dir, pos) { + Some(c2) => c2 == self.c || input.fold(c2) == self.c, + _ => false, + } + } +} + +/// Insn::CharSet +pub struct CharSet<'a> { + pub chars: &'a [u32; MAX_CHAR_SET_LENGTH], +} + +impl SingleCharMatcher for CharSet<'_> { + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + match cursor::next(input, dir, pos) { + Some(c) => charset_contains(self.chars, c.as_u32()), + None => false, + } + } +} + +/// Insn::Bracket +pub struct Bracket<'a> { + pub bc: &'a BracketContents, +} + +impl SingleCharMatcher for Bracket<'_> { + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + match cursor::next(input, dir, pos) { + Some(c) => Input::CharProps::bracket(self.bc, c), + _ => false, + } + } +} + +/// Insn::MatchAny +pub struct MatchAny {} +impl MatchAny { + pub fn new() -> Self { + Self {} + } +} +impl SingleCharMatcher for MatchAny { + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + // If there is a character, it counts as a match. + cursor::next(input, dir, pos).is_some() + } +} + +/// Insn::MatchAnyExceptLineTerminator +pub struct MatchAnyExceptLineTerminator {} +impl MatchAnyExceptLineTerminator { + pub fn new() -> Self { + Self {} + } +} +impl SingleCharMatcher + for MatchAnyExceptLineTerminator +{ + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + match cursor::next(input, dir, pos) { + Some(c2) => !Input::CharProps::is_line_terminator(c2), + _ => false, + } + } +} + +/// Any ByteSet may match a single char. +pub struct MatchByteSet<'a, Bytes: ByteSet> { + pub bytes: &'a Bytes, +} + +impl SingleCharMatcher + for MatchByteSet<'_, Bytes> +{ + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + if Input::CODE_UNITS_ARE_BYTES { + // Code units are bytes so we can skip decoding the full element. + cursor::next_byte(input, dir, pos).is_some_and(|b| self.bytes.contains(b)) + } else { + // Must decode the full element. + cursor::next(input, dir, pos) + .and_then(|c| c.as_u32().try_into().ok()) + .is_some_and(|c| self.bytes.contains(c)) + } + } +} + +/// Provide a variant for ByteArraySet where we hold it directly. +/// The arrays are small and so we don't want to indirect through a pointer. +pub struct MatchByteArraySet(pub ByteArraySet); + +impl SingleCharMatcher + for MatchByteArraySet +{ + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + if let Some(b) = cursor::next_byte(input, dir, pos) { + self.0.contains(b) + } else { + false + } + } +} + +/// A ByteSeq of length <= 4 may match a single char. +pub struct MatchByteSeq<'a, const N: usize>(pub &'a [u8; N]); + +impl SingleCharMatcher + for MatchByteSeq<'_, N> +{ + #[inline(always)] + fn matches(&self, input: &Input, dir: Dir, pos: &mut Input::Position) -> bool { + debug_assert!(N <= 4, "This looks like it could match more than one char"); + cursor::try_match_lit(input, dir, pos, self.0) + } +} diff --git a/third_party/regress/src/startpredicate.rs b/third_party/regress/src/startpredicate.rs new file mode 100644 index 00000000..217327ce --- /dev/null +++ b/third_party/regress/src/startpredicate.rs @@ -0,0 +1,223 @@ +//! Support for quickly finding potential match locations. +use crate::bytesearch::ByteBitmap; +use crate::codepointset; +use crate::insn::StartPredicate; +use crate::ir; +use crate::ir::Node; +use crate::util::{add_utf8_first_bytes_to_bitmap, utf8_first_byte}; +#[cfg(not(feature = "std"))] +use alloc::{boxed::Box, vec::Vec}; +use memchr::memmem; + +/// Check if a node is anchored to the start of the line/string. +/// Returns true if the node begins with a StartOfLine anchor. +fn is_start_anchored(n: &Node) -> bool { + match n { + Node::Anchor { + anchor_type: ir::AnchorType::StartOfLine, + multiline, + } => !multiline, + Node::Cat(nodes) => { + // For concatenation, check if the first node is start-anchored + nodes.first().is_some_and(is_start_anchored) + } + Node::CaptureGroup { contents, .. } => is_start_anchored(contents), + // Other nodes are not anchored + _ => false, + } +} + +/// Convert the code point set to a first-byte bitmap. +/// That is, make a list of all of the possible first bytes of every contained +/// code point, and store that in a bitmap. +fn cps_to_first_byte_bitmap(input: &codepointset::CodePointSet) -> Box { + let mut bitmap = Box::::default(); + for iv in input.intervals() { + add_utf8_first_bytes_to_bitmap(*iv, &mut bitmap); + } + bitmap +} + +/// The "IR" for a start predicate. +enum AbstractStartPredicate { + /// No predicate. + Arbitrary, + + /// Sequence of non-empty bytes. + Sequence(Vec), + + /// Set of bytes. + Set(Box), +} + +impl AbstractStartPredicate { + /// \return the disjunction of two predicates. + /// That is, a predicate that matches x OR y. + fn disjunction(x: Self, y: Self) -> Self { + match (x, y) { + (Self::Arbitrary, _) => Self::Arbitrary, + (_, Self::Arbitrary) => Self::Arbitrary, + + (Self::Sequence(s1), Self::Sequence(s2)) => { + // Compute the length of the shared prefix. + let shared_len = s1.iter().zip(s2.iter()).take_while(|(a, b)| a == b).count(); + debug_assert!(s1[..shared_len] == s2[..shared_len]); + if shared_len > 0 { + // Use the shared prefix. + Self::Sequence(s1[..shared_len].to_vec()) + } else { + // Use a set of their first byte. + Self::Set(Box::new(ByteBitmap::new(&[s1[0], s2[0]]))) + } + } + + (Self::Set(mut s1), Self::Set(s2)) => { + s1.bitor(s2.as_ref()); + Self::Set(s1) + } + + (Self::Set(mut s1), Self::Sequence(s2)) => { + // Add first byte to set. + s1.set(s2[0]); + Self::Set(s1) + } + + (Self::Sequence(s1), Self::Set(mut s2)) => { + s2.set(s1[0]); + Self::Set(s2) + } + } + } + + /// Resolve ourselves to a concrete start predicate. + fn resolve_to_insn(self) -> StartPredicate { + match self { + Self::Arbitrary => StartPredicate::Arbitrary, + Self::Sequence(vals) => match vals.len() { + 0 => StartPredicate::Arbitrary, + 1 => StartPredicate::ByteSet1([vals[0]]), + _ => StartPredicate::ByteSeq(Box::new(memmem::Finder::new(&vals).into_owned())), + }, + Self::Set(bm) => match bm.count_bits() { + 0 => StartPredicate::Arbitrary, + 1 => StartPredicate::ByteSet1(bm.as_array()), + 2 => StartPredicate::ByteSet2(bm.as_array()), + 3 => StartPredicate::ByteSet3(bm.as_array()), + _ => StartPredicate::ByteBracket(*bm), + }, + } + } +} + +/// Compute any start-predicate for a node.. +/// If this returns None, then the instruction is conceptually zero-width (e.g. +/// lookahead assertion) and does not contribute to the predicate. +/// If this returns StartPredicate::Arbitrary, then there is no predicate. +fn compute_start_predicate(n: &Node) -> Option { + let arbitrary = Some(AbstractStartPredicate::Arbitrary); + match n { + Node::ByteSequence(bytevec) => Some(AbstractStartPredicate::Sequence(bytevec.clone())), + Node::ByteSet(bytes) => Some(AbstractStartPredicate::Set(Box::new(ByteBitmap::new( + bytes, + )))), + + Node::Empty => arbitrary, + Node::Goal => arbitrary, + Node::BackRef(..) => arbitrary, + + Node::CharSet(chars) => { + // Pick the first bytes out. + let bytes = chars + .iter() + .map(|&c| utf8_first_byte(c)) + .collect::>(); + Some(AbstractStartPredicate::Set(Box::new(ByteBitmap::new( + &bytes, + )))) + } + + // We assume that most char nodes have been optimized to ByteSeq or AnyBytes2, so skip + // these. + // TODO: we could support icase through bitmap of de-folded first bytes. + Node::Char { .. } => arbitrary, + + // Cats return the first non-None value, if any. + Node::Cat(nodes) => nodes.iter().filter_map(compute_start_predicate).next(), + + // MatchAny (aka .) is too common to do a fast prefix search for. + Node::MatchAny => arbitrary, + + // MatchAnyExceptLineTerminator (aka .) is too common to do a fast prefix search for. + Node::MatchAnyExceptLineTerminator => arbitrary, + + // TODO: can probably exploit some of these. + Node::Anchor { .. } => arbitrary, + Node::WordBoundary { .. } => arbitrary, + + // Capture groups delegate to their contents. + Node::CaptureGroup { contents, .. } => compute_start_predicate(contents), + + // Zero-width assertions are one of the few instructions that impose no start predicate. + Node::LookaroundAssertion { .. } => None, + + Node::Loop { loopee, quant, .. } => { + // TODO: we could try to join two predicates if the loop were optional. + if quant.min > 0 { + compute_start_predicate(loopee) + } else { + arbitrary + } + } + + Node::Loop1CharBody { loopee, quant } => { + // TODO: we could try to join two predicates if the loop were optional. + if quant.min > 0 { + compute_start_predicate(loopee) + } else { + arbitrary + } + } + + // This one is interesting - we compute the disjunction of the predicates of our two arms. + Node::Alt(left, right) => { + if let (Some(x), Some(y)) = ( + compute_start_predicate(left), + compute_start_predicate(right), + ) { + Some(AbstractStartPredicate::disjunction(x, y)) + } else { + // This indicates that one of our branches could match the empty string. + arbitrary + } + } + + // Brackets get a bitmap. + Node::Bracket(bc) => { + // If our bracket is inverted, construct the set of code points not contained. + let storage; + let cps = if bc.invert { + storage = bc.cps.inverted(); + &storage + } else { + &bc.cps + }; + let bitmap = cps_to_first_byte_bitmap(cps); + Some(AbstractStartPredicate::Set(bitmap)) + } + } +} + +/// \return the start predicate for a Regex. +pub fn predicate_for_re(re: &ir::Regex) -> StartPredicate { + // Check if the regex is anchored to the start - if so, we can optimize + // by avoiding string searching entirely. However, only do this when + // multiline mode is disabled, since in multiline mode ^ can match + // at the beginning of any line, not just the string start. + if is_start_anchored(&re.node) && !re.flags.multiline { + return StartPredicate::StartAnchored; + } + + compute_start_predicate(&re.node) + .unwrap_or(AbstractStartPredicate::Arbitrary) + .resolve_to_insn() +} diff --git a/third_party/regress/src/types.rs b/third_party/regress/src/types.rs new file mode 100644 index 00000000..81e49208 --- /dev/null +++ b/third_party/regress/src/types.rs @@ -0,0 +1,98 @@ +use crate::codepointset::CodePointSet; +use crate::position::PositionType; +#[cfg(not(feature = "std"))] +use alloc::string::String; +use core::ops; + +/// A group index is u16. +/// CaptureGroupID 0 corresponds to the first capture group. +pub type CaptureGroupID = u16; + +/// The name of a named capture group. +pub type CaptureGroupName = String; + +/// The maximum number of capture groups supported. +pub const MAX_CAPTURE_GROUPS: usize = 65535; + +/// The maximum number of loops supported. +pub const MAX_LOOPS: usize = 65535; +pub type LoopID = u16; + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum CharacterClassType { + Digits, + Spaces, + Words, +} + +/// The stuff in a bracket. +#[derive(Debug, Clone, Default)] +pub struct BracketContents { + pub invert: bool, + pub cps: CodePointSet, +} + +impl BracketContents { + // Return true if the bracket is empty. + pub fn is_empty(&self) -> bool { + match self.invert { + false => self.cps.is_empty(), + true => self.cps.contains_all_codepoints(), + } + } +} + +/// An instruction pointer. +pub type IP = usize; + +/// Representation of a loop. +#[derive(Debug, Copy, Clone)] +pub struct LoopData { + pub iters: usize, + pub entry: Position, +} + +impl LoopData { + pub fn new(entry: Position) -> LoopData { + LoopData { iters: 0, entry } + } +} + +/// Representation of a capture group. +#[derive(Debug, Copy, Clone)] +pub struct GroupData { + pub start: Option, + pub end: Option, +} + +impl GroupData { + pub fn new() -> GroupData { + GroupData { + start: None, + end: None, + } + } + + pub fn start_matched(&self) -> bool { + self.start.is_some() + } + + pub fn end_matched(&self) -> bool { + self.end.is_some() + } + + pub fn as_range(&self) -> Option> { + // Note: we may have only start_matched (if forwards) or end_matched (if + // backwards) set. + match (self.start, self.end) { + (Some(start), Some(end)) => Some(ops::Range { start, end }), + _ => None, + } + } + + /// Reset the group to "not entered." + pub fn reset(&mut self) { + self.start = None; + self.end = None; + } +} diff --git a/third_party/regress/src/unicode.rs b/third_party/regress/src/unicode.rs new file mode 100644 index 00000000..1618f3c7 --- /dev/null +++ b/third_party/regress/src/unicode.rs @@ -0,0 +1,581 @@ +use crate::codepointset::{CodePointSet, Interval}; +use crate::unicodetables::{ + FOLDS, TO_UPPERCASE, binary_property_ranges, general_category_property_value_ranges, + script_extensions_value_ranges, script_value_ranges, string_property_sets, + unicode_property_binary_from_str, unicode_property_value_general_category_from_str, + unicode_property_value_script_from_str, unicode_string_property_from_str, +}; +use crate::util::SliceHelp; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; +use core::cmp::Ordering; + +// CodePointRange packs a code point and a length together into a u32. +// We currently do not need to store any information about code points in plane 16 (U+100000), +// which are private use, so we only need 20 bits of code point storage; +// the remaining 12 can be the length. +// The length is stored with a bias of -1, so the last codepoint may be obtained by adding the "length" and the first code point. +const CODE_POINT_BITS: u32 = 20; +const LENGTH_BITS: u32 = 32 - CODE_POINT_BITS; + +#[derive(Copy, Clone, Debug)] +pub struct CodePointRange(u32); + +// This will trigger an error in const functions if $x is false. +macro_rules! const_assert_true { + ($x:expr $(,)*) => { + [()][!$x as usize]; + }; +} + +impl CodePointRange { + #[inline(always)] + pub const fn from(start: u32, len: u32) -> Self { + const_assert_true!(start < (1 << CODE_POINT_BITS)); + const_assert_true!(len > 0 && len <= (1 << LENGTH_BITS)); + const_assert_true!((start + len - 1) < ((1 << CODE_POINT_BITS) - 1)); + CodePointRange((start << LENGTH_BITS) | (len - 1)) + } + + #[inline(always)] + const fn len_minus_1(self) -> u32 { + self.0 & ((1 << LENGTH_BITS) - 1) + } + + // \return the first codepoint in the range. + #[inline(always)] + pub const fn first(self) -> u32 { + self.0 >> LENGTH_BITS + } + + // \return the last codepoint in the range. + #[inline(always)] + pub const fn last(self) -> u32 { + self.first() + self.len_minus_1() + } +} + +// The "extra" field contains a predicate mask in the low bits and a signed delta amount in the high bits. +// A code point only transforms if its difference from the range base is 0 once masked. +const PREDICATE_MASK_BITS: u32 = 4; + +pub(crate) struct FoldRange { + /// The range of codepoints. + pub(crate) range: CodePointRange, + + /// Combination of the signed delta amount and predicate mask. + pub(crate) extra: i32, +} + +impl FoldRange { + #[inline(always)] + pub const fn from(start: u32, length: u32, delta: i32, modulo: u8) -> Self { + const_assert_true!(modulo.is_power_of_two()); + let mask = (modulo - 1) as i32; + const_assert_true!(mask < (1 << PREDICATE_MASK_BITS)); + const_assert_true!(((delta << PREDICATE_MASK_BITS) >> PREDICATE_MASK_BITS) == delta); + let extra = mask | (delta << PREDICATE_MASK_BITS); + FoldRange { + range: CodePointRange::from(start, length), + extra, + } + } + #[inline(always)] + fn first(&self) -> u32 { + self.range.first() + } + + #[inline(always)] + fn last(&self) -> u32 { + self.range.last() + } + + #[inline(always)] + fn delta(&self) -> i32 { + self.extra >> PREDICATE_MASK_BITS + } + + #[inline(always)] + fn predicate_mask(&self) -> u32 { + (self.extra as u32) & ((1 << PREDICATE_MASK_BITS) - 1) + } + + fn add_delta(&self, cu: u32) -> u32 { + let cs = (cu as i32) + self.delta(); + core::debug_assert!(0 <= cs && cs <= 0x10FFFF); + cs as u32 + } + + /// \return the Interval of transformed-to code points. + fn transformed_to(&self) -> Interval { + Interval { + first: self.add_delta(self.first()), + last: self.add_delta(self.last()), + } + } + + /// \return the Interval of transformed-from code points. + fn transformed_from(&self) -> Interval { + Interval { + first: self.first(), + last: self.last(), + } + } + + fn can_apply(&self, cu: u32) -> bool { + self.transformed_from().contains(cu) + } + + fn apply(&self, cu: u32) -> u32 { + debug_assert!(self.can_apply(cu), "Cannot apply to this code point"); + let offset = cu - self.first(); + if (offset & self.predicate_mask()) == 0 { + self.add_delta(cu) + } else { + cu + } + } +} + +/// Implements the `Canonicalize` method from the [spec]. +/// +/// [spec]: https://tc39.es/ecma262/#sec-runtime-semantics-canonicalize-ch +pub(crate) fn fold_code_point(cu: u32, unicode: bool) -> u32 { + if unicode { + return fold(cu); + } + uppercase(cu) +} + +pub fn fold(cu: u32) -> u32 { + let searched = FOLDS.binary_search_by(|fr| { + if fr.first() > cu { + Ordering::Greater + } else if fr.last() < cu { + Ordering::Less + } else { + Ordering::Equal + } + }); + if let Ok(index) = searched { + let fr: &FoldRange = if cfg!(feature = "prohibit-unsafe") { + unsafe { FOLDS.get_unchecked(index) } + } else { + FOLDS.get(index).expect("Invalid index") + }; + fr.apply(cu) + } else { + cu + } +} + +fn uppercase(cu: u32) -> u32 { + let searched = TO_UPPERCASE.binary_search_by(|fr| { + if fr.first() > cu { + Ordering::Greater + } else if fr.last() < cu { + Ordering::Less + } else { + Ordering::Equal + } + }); + if let Ok(index) = searched { + let fr: &FoldRange = if cfg!(feature = "prohibit-unsafe") { + unsafe { TO_UPPERCASE.get_unchecked(index) } + } else { + TO_UPPERCASE.get(index).expect("Invalid index") + }; + fr.apply(cu) + } else { + cu + } +} + +// Add all folded characters in the given interval to the given code point set. +// This skips characters which fold to themselves. +fn fold_interval(iv: Interval, recv: &mut CodePointSet) { + let overlaps = FOLDS.equal_range_by(|tr| { + if tr.first() > iv.last { + Ordering::Greater + } else if tr.last() < iv.first { + Ordering::Less + } else { + Ordering::Equal + } + }); + for fr in &FOLDS[overlaps] { + debug_assert!( + fr.transformed_from().overlaps(iv), + "Interval does not overlap transform" + ); + // Find the (inclusive) range of our interval that this transform covers. + let first_trans = core::cmp::max(fr.first(), iv.first); + let last_trans = core::cmp::min(fr.last(), iv.last); + + let modulo = fr.predicate_mask() + 1; + if modulo == 1 { + // Optimization: when modulo is 1, every character in range gets transformed + for cu in first_trans..(last_trans + 1) { + let cs = fr.add_delta(cu); + if cs != cu { + recv.add_one(cs); + } + } + } else { + // Optimization: walk by modulo amount instead of checking every character + let offset_start = first_trans - fr.first(); + let start_aligned = first_trans + ((modulo - (offset_start % modulo)) % modulo); + + let mut cu = start_aligned; + while cu <= last_trans { + let cs = fr.add_delta(cu); + recv.add_one(cs); + cu += modulo; + } + } + } +} + +/// Find all characters that fold into the given interval and add them to the given code point set. +/// This skips characters which fold to themselves. +fn unfold_interval(iv: Interval, recv: &mut CodePointSet) { + // Note: We still need to check all ranges because the relationship between + // transformed_from and transformed_to intervals can be complex + for tr in FOLDS.iter() { + if !iv.overlaps(tr.transformed_to()) { + continue; + } + + let modulo = tr.predicate_mask() + 1; + let first_source = tr.first(); + let last_source = tr.last(); + + let mut process_cp = |cp| { + let tcp = tr.apply(cp); + if tcp != cp && iv.contains(tcp) { + recv.add_one(cp); + } + }; + + if modulo == 1 { + // Optimization: when modulo is 1, every character in range gets transformed + for cp in first_source..(last_source + 1) { + process_cp(cp); + } + } else { + // Walk by modulo amount instead of checking every character + let mut cp = first_source; + while cp <= last_source { + process_cp(cp); + cp += modulo; + } + } + } +} + +/// \return all the characters which fold to c's fold. +/// This is a linear search across all ranges. +/// The result always contains c. +pub fn unfold_char(c: u32) -> Vec { + let mut res = vec![c]; + let fcp = fold(c); + if fcp != c { + res.push(fcp); + } + // TODO: optimize ASCII case. + for tr in FOLDS.iter() { + if !tr.transformed_to().contains(fcp) { + continue; + } + for cp in tr.transformed_from().codepoints() { + // TODO: this can be optimized. + let tcp = tr.apply(cp); + if tcp == fcp { + res.push(cp); + } + } + } + res.sort_unstable(); + res.dedup(); + res +} + +pub(crate) fn unfold_uppercase_char(c: u32) -> Vec { + let mut res = vec![c]; + let fcp = uppercase(c); + if fcp != c { + res.push(fcp); + } + for tr in TO_UPPERCASE.iter() { + if !tr.transformed_to().contains(fcp) { + continue; + } + for cp in tr.transformed_from().codepoints() { + let tcp = tr.apply(cp); + if tcp == fcp { + res.push(cp); + } + } + } + res.sort_unstable(); + res.dedup(); + res +} + +// Fold every character in \p input, then find all the prefolds. +pub fn add_icase_code_points(mut input: CodePointSet) -> CodePointSet { + let mut folded = input.clone(); + for iv in input.intervals() { + fold_interval(*iv, &mut folded) + } + + // Reuse input storage. + input.clone_from(&folded); + for iv in folded.intervals() { + unfold_interval(*iv, &mut input); + } + input +} + +pub(crate) enum PropertyEscapeKind { + CharacterClass(&'static [Interval]), + StringSet(&'static [&'static [u32]]), +} + +#[derive(Debug, Copy, Clone)] +pub(crate) enum UnicodePropertyName { + GeneralCategory, + Script, + ScriptExtensions, +} + +pub(crate) fn unicode_property_name_from_str(s: &str) -> Option { + use UnicodePropertyName::*; + + match s { + "General_Category" | "gc" => Some(GeneralCategory), + "Script" | "sc" => Some(Script), + "Script_Extensions" | "scx" => Some(ScriptExtensions), + _ => None, + } +} + +pub(crate) fn unicode_property_from_str( + s: &str, + name: Option, + unicode_sets: bool, +) -> Option { + match name { + Some(UnicodePropertyName::GeneralCategory) => Some(PropertyEscapeKind::CharacterClass( + general_category_property_value_ranges( + &unicode_property_value_general_category_from_str(s)?, + ), + )), + Some(UnicodePropertyName::Script) => Some(PropertyEscapeKind::CharacterClass( + script_value_ranges(&unicode_property_value_script_from_str(s)?), + )), + Some(UnicodePropertyName::ScriptExtensions) => Some(PropertyEscapeKind::CharacterClass( + script_extensions_value_ranges(&unicode_property_value_script_from_str(s)?), + )), + None => { + if let Some(value) = unicode_property_binary_from_str(s) { + return Some(PropertyEscapeKind::CharacterClass(binary_property_ranges( + &value, + ))); + } + if unicode_sets && let Some(value) = unicode_string_property_from_str(s) { + return Some(PropertyEscapeKind::StringSet(string_property_sets(&value))); + } + Some(PropertyEscapeKind::CharacterClass( + general_category_property_value_ranges( + &unicode_property_value_general_category_from_str(s)?, + ), + )) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::collections::HashMap; + + // Map from folded char to the chars that folded to it. + // If an entry is missing, it means either nothing folds to the char, + // or it folds exclusively to itself; this can be determined by comparing + // the char to its fold. + fn get_unfold_map() -> HashMap> { + let mut unfold_map: HashMap> = HashMap::new(); + for c in 0..=0x10FFFF { + let fc = fold(c); + if fc != c { + unfold_map.entry(fc).or_default().push(c); + } + } + + // We neglected self-folds - add them now, but only for entries + // where something else folds to it, else our map would be quite large. + // Also sort them all. + for (&k, v) in unfold_map.iter_mut() { + assert_eq!(k, fold(k), "folds should be idempotent"); + v.push(k); + v.sort_unstable(); + } + unfold_map + } + + #[test] + fn test_folds() { + for c in 0..0x41 { + assert_eq!(fold(c), c); + } + for c in 0x41..=0x5A { + assert_eq!(fold(c), c + 0x20); + } + assert_eq!(fold(0xB5), 0x3BC); + assert_eq!(fold(0xC0), 0xE0); + + assert_eq!(fold(0x1B8), 0x1B9); + assert_eq!(fold(0x1B9), 0x1B9); + assert_eq!(fold(0x1BA), 0x1BA); + assert_eq!(fold(0x1BB), 0x1BB); + assert_eq!(fold(0x1BC), 0x1BD); + assert_eq!(fold(0x1BD), 0x1BD); + + for c in 0x1F8..0x21F { + if c % 2 == 0 { + assert_eq!(fold(c), c + 1); + } else { + assert_eq!(fold(c), c); + } + } + + assert_eq!(fold(0x37F), 0x3F3); + assert_eq!(fold(0x380), 0x380); + assert_eq!(fold(0x16E40), 0x16E60); + assert_eq!(fold(0x16E41), 0x16E61); + assert_eq!(fold(0x16E42), 0x16E62); + assert_eq!(fold(0x1E900), 0x1E922); + assert_eq!(fold(0x1E901), 0x1E923); + for c in 0xF0000..=0x10FFFF { + assert_eq!(fold(c), c); + } + } + + #[test] + fn test_fold_idempotent() { + for c in 0..=0x10FFFF { + let fc = fold(c); + let ffc = fold(fc); + assert_eq!(ffc, fc); + } + } + + #[test] + fn test_unfolds_refold() { + for c in 0..=0x10FFFF { + let fc = fold(c); + let unfolds = unfold_char(c); + for uc in unfolds { + assert_eq!(fold(uc), fc); + } + } + } + + #[test] + fn test_unfold_chars() { + let unfold_map = get_unfold_map(); + for c in 0..=0x10FFFF { + let mut unfolded = unfold_char(c); + unfolded.sort_unstable(); + let fc = fold(c); + if let Some(expected) = unfold_map.get(&fc) { + // Explicit list of unfolds. + assert_eq!(&unfolded, expected); + } else { + // No entry in our testing unfold map: that means that either the + // character folds to itself and nothing else does, or the character + // folds to a different character - but that different character + // should fold to itself (folding is idempotent) so we should always + // have multiple characters in that case. Therefore we expect this + // character's unfolds to be itself exclusively. + assert_eq!(&unfolded, &[c]); + } + } + } + + #[test] + fn test_add_icase_code_points() { + let unfold_map = get_unfold_map(); + let locs = [ + 0x0, 0x42, 0x100, 0xdeba, 0x11419, 0x278f8, 0x2e000, 0x35df7, 0x462d6, 0x4bc29, + 0x4f4c0, 0x58a9b, 0x5bafc, 0x62383, 0x66d60, 0x6974a, 0x77628, 0x87804, 0x9262b, + 0x931e4, 0xaa08c, 0xad7a8, 0xca6b0, 0xcce27, 0xcd897, 0xcf5e7, 0xe2802, 0xe561b, + 0xe5f43, 0xf4339, 0xfb78c, 0xfc5ee, 0x104fa9, 0x10e402, 0x10e6cf, 0x10FFFF, + ]; + for (idx, &first) in locs.iter().enumerate() { + // Keep a running set of the unfolded code points we expect to be in the + // range [first, last]. + let mut expected = CodePointSet::default(); + let mut from = first; + for &last in &locs[idx..] { + // Add both folded and unfolded characters to expected. + for c in from..=last { + let fc = fold(c); + if let Some(unfolded) = unfold_map.get(&fc) { + // Some nontrival set of characters fold to fc. + for &ufc in unfolded { + expected.add_one(ufc); + } + } else { + // Only fc folds to fc. + expected.add_one(fc); + } + } + let mut input = CodePointSet::new(); + input.add(Interval { first, last }); + let folded = add_icase_code_points(input); + assert_eq!(folded, expected); + from = last; + } + } + } + + #[test] + fn test_fold_interval() { + let locs = [ + 0, 0x894, 0x59ac, 0xfa64, 0x10980, 0x12159, 0x16b8d, 0x1aaa2, 0x1f973, 0x1fcd4, + 0x20c35, 0x23d8a, 0x276af, 0x2c6b8, 0x2fb25, 0x30b9b, 0x338ad, 0x35ab3, 0x38d37, + 0x3bfa7, 0x3fba6, 0x404c9, 0x44572, 0x480c9, 0x4b5c4, 0x4f371, 0x5a9fa, 0x5ad6c, + 0x5e395, 0x5f103, 0x5fa98, 0x617fa, 0x6500e, 0x68890, 0x6a3fc, 0x6eab3, 0x704a6, + 0x70c22, 0x72efb, 0x737cc, 0x76796, 0x79da8, 0x7a450, 0x7b023, 0x7cc5c, 0x82027, + 0x84ef4, 0x8ac66, 0x8b898, 0x8bd1a, 0x95841, 0x98a48, 0x9e6cd, 0xa035a, 0xa41fb, + 0xa50e3, 0xa6387, 0xa7ba1, 0xaad9a, 0xabed8, 0xacc88, 0xb2737, 0xb31b1, 0xb6daf, + 0xb7ff4, 0xba2b4, 0xbde4f, 0xbe38b, 0xbe7a5, 0xc4eb2, 0xc5670, 0xc7703, 0xc995d, + 0xccb72, 0xcdfe3, 0xcfc99, 0xd09eb, 0xd2773, 0xd357d, 0xd6696, 0xd9aec, 0xdc3fa, + 0xdc8ae, 0xdc9d5, 0xde31d, 0xe2edb, 0xe652b, 0xe92d5, 0xebf2d, 0xee335, 0xef45f, + 0xf4280, 0xf74b1, 0xf9ac4, 0xfafca, 0x10208d, 0x107d63, 0x10821e, 0x108818, 0x10911f, + 0x10b6fd, 0x10FFFF, + ]; + for (idx, &first) in locs.iter().enumerate() { + // Keep a running set of the folded code points we expect to be in the + // range [first, last]. + let mut expected = CodePointSet::default(); + let mut from = first; + for &last in &locs[idx..] { + // Add characters to expected which do not fold to themselves. + for c in from..=last { + let fc = fold(c); + if fc != c { + expected.add_one(fc); + } + } + let mut cps = CodePointSet::default(); + fold_interval(Interval { first, last }, &mut cps); + assert_eq!(cps.intervals(), expected.intervals()); + + from = last; + } + } + } +} diff --git a/third_party/regress/src/unicodetables.rs b/third_party/regress/src/unicodetables.rs new file mode 100644 index 00000000..5ac592b7 --- /dev/null +++ b/third_party/regress/src/unicodetables.rs @@ -0,0 +1,33975 @@ +// DO NOT EDIT! This file is autogenerated from gen-unicode. +use crate::codepointset::Interval; +use crate::unicode::FoldRange; + +const ALPHABETIC: [Interval; 761] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(837, 837), + Interval::new(867, 884), + Interval::new(886, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1369), + Interval::new(1376, 1416), + Interval::new(1456, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1552, 1562), + Interval::new(1568, 1623), + Interval::new(1625, 1631), + Interval::new(1646, 1747), + Interval::new(1749, 1756), + Interval::new(1761, 1768), + Interval::new(1773, 1775), + Interval::new(1786, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1855), + Interval::new(1869, 1969), + Interval::new(1994, 2026), + Interval::new(2036, 2037), + Interval::new(2042, 2042), + Interval::new(2048, 2071), + Interval::new(2074, 2092), + Interval::new(2112, 2136), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2199, 2199), + Interval::new(2208, 2249), + Interval::new(2260, 2271), + Interval::new(2275, 2281), + Interval::new(2288, 2363), + Interval::new(2365, 2380), + Interval::new(2382, 2384), + Interval::new(2389, 2403), + Interval::new(2417, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2493, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2508), + Interval::new(2510, 2510), + Interval::new(2519, 2519), + Interval::new(2524, 2525), + Interval::new(2527, 2531), + Interval::new(2544, 2545), + Interval::new(2556, 2556), + Interval::new(2561, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2636), + Interval::new(2641, 2641), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2672, 2677), + Interval::new(2689, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2749, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2764), + Interval::new(2768, 2768), + Interval::new(2784, 2787), + Interval::new(2809, 2812), + Interval::new(2817, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2877, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2892), + Interval::new(2902, 2903), + Interval::new(2908, 2909), + Interval::new(2911, 2915), + Interval::new(2929, 2929), + Interval::new(2946, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3020), + Interval::new(3024, 3024), + Interval::new(3031, 3031), + Interval::new(3072, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3133, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3148), + Interval::new(3157, 3158), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3171), + Interval::new(3200, 3203), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3261, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3276), + Interval::new(3285, 3286), + Interval::new(3292, 3294), + Interval::new(3296, 3299), + Interval::new(3313, 3315), + Interval::new(3328, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3386), + Interval::new(3389, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3404), + Interval::new(3406, 3406), + Interval::new(3412, 3415), + Interval::new(3423, 3427), + Interval::new(3450, 3455), + Interval::new(3457, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3570, 3571), + Interval::new(3585, 3642), + Interval::new(3648, 3654), + Interval::new(3661, 3661), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3769), + Interval::new(3771, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3789, 3789), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3904, 3911), + Interval::new(3913, 3948), + Interval::new(3953, 3971), + Interval::new(3976, 3991), + Interval::new(3993, 4028), + Interval::new(4096, 4150), + Interval::new(4152, 4152), + Interval::new(4155, 4159), + Interval::new(4176, 4239), + Interval::new(4250, 4253), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4992, 5007), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5870, 5880), + Interval::new(5888, 5907), + Interval::new(5919, 5939), + Interval::new(5952, 5971), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6002, 6003), + Interval::new(6016, 6067), + Interval::new(6070, 6088), + Interval::new(6103, 6103), + Interval::new(6108, 6108), + Interval::new(6176, 6264), + Interval::new(6272, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6432, 6443), + Interval::new(6448, 6456), + Interval::new(6480, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6656, 6683), + Interval::new(6688, 6750), + Interval::new(6753, 6772), + Interval::new(6823, 6823), + Interval::new(6847, 6848), + Interval::new(6860, 6862), + Interval::new(6912, 6963), + Interval::new(6965, 6979), + Interval::new(6981, 6988), + Interval::new(7040, 7081), + Interval::new(7084, 7087), + Interval::new(7098, 7141), + Interval::new(7143, 7153), + Interval::new(7168, 7222), + Interval::new(7245, 7247), + Interval::new(7258, 7293), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7414), + Interval::new(7418, 7418), + Interval::new(7424, 7615), + Interval::new(7635, 7668), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8473, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8495, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(9398, 9449), + Interval::new(11264, 11492), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11631), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(11744, 11775), + Interval::new(11823, 11823), + Interval::new(12293, 12295), + Interval::new(12321, 12329), + Interval::new(12337, 12341), + Interval::new(12344, 12348), + Interval::new(12353, 12438), + Interval::new(12445, 12447), + Interval::new(12449, 12538), + Interval::new(12540, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 42124), + Interval::new(42192, 42237), + Interval::new(42240, 42508), + Interval::new(42512, 42527), + Interval::new(42538, 42539), + Interval::new(42560, 42606), + Interval::new(42612, 42619), + Interval::new(42623, 42735), + Interval::new(42775, 42783), + Interval::new(42786, 42888), + Interval::new(42891, 42972), + Interval::new(42993, 43013), + Interval::new(43015, 43047), + Interval::new(43072, 43123), + Interval::new(43136, 43203), + Interval::new(43205, 43205), + Interval::new(43250, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43263), + Interval::new(43274, 43306), + Interval::new(43312, 43346), + Interval::new(43360, 43388), + Interval::new(43392, 43442), + Interval::new(43444, 43455), + Interval::new(43471, 43471), + Interval::new(43488, 43503), + Interval::new(43514, 43518), + Interval::new(43520, 43574), + Interval::new(43584, 43597), + Interval::new(43616, 43638), + Interval::new(43642, 43710), + Interval::new(43712, 43712), + Interval::new(43714, 43714), + Interval::new(43739, 43741), + Interval::new(43744, 43759), + Interval::new(43762, 43765), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 44010), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65019), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(65382, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65856, 65908), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66304, 66335), + Interval::new(66349, 66378), + Interval::new(66384, 66426), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66513, 66517), + Interval::new(66560, 66717), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68324), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68864, 68903), + Interval::new(68938, 68965), + Interval::new(68969, 68969), + Interval::new(68975, 68997), + Interval::new(69248, 69289), + Interval::new(69291, 69292), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69370, 69372), + Interval::new(69376, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69445), + Interval::new(69488, 69505), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69632, 69701), + Interval::new(69745, 69749), + Interval::new(69760, 69816), + Interval::new(69826, 69826), + Interval::new(69840, 69864), + Interval::new(69888, 69938), + Interval::new(69956, 69959), + Interval::new(69968, 70002), + Interval::new(70006, 70006), + Interval::new(70016, 70079), + Interval::new(70081, 70084), + Interval::new(70094, 70095), + Interval::new(70106, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70196), + Interval::new(70199, 70199), + Interval::new(70206, 70209), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70376), + Interval::new(70400, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70461, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70476), + Interval::new(70480, 70480), + Interval::new(70487, 70487), + Interval::new(70493, 70499), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70605), + Interval::new(70609, 70609), + Interval::new(70611, 70611), + Interval::new(70656, 70721), + Interval::new(70723, 70725), + Interval::new(70727, 70730), + Interval::new(70751, 70753), + Interval::new(70784, 70849), + Interval::new(70852, 70853), + Interval::new(70855, 70855), + Interval::new(71040, 71093), + Interval::new(71096, 71102), + Interval::new(71128, 71133), + Interval::new(71168, 71230), + Interval::new(71232, 71232), + Interval::new(71236, 71236), + Interval::new(71296, 71349), + Interval::new(71352, 71352), + Interval::new(71424, 71450), + Interval::new(71453, 71466), + Interval::new(71488, 71494), + Interval::new(71680, 71736), + Interval::new(71840, 71903), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71989), + Interval::new(71991, 71992), + Interval::new(71995, 71996), + Interval::new(71999, 72002), + Interval::new(72096, 72103), + Interval::new(72106, 72151), + Interval::new(72154, 72159), + Interval::new(72161, 72161), + Interval::new(72163, 72164), + Interval::new(72192, 72242), + Interval::new(72245, 72254), + Interval::new(72272, 72343), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72544, 72551), + Interval::new(72640, 72672), + Interval::new(72704, 72712), + Interval::new(72714, 72758), + Interval::new(72760, 72766), + Interval::new(72768, 72768), + Interval::new(72818, 72847), + Interval::new(72850, 72871), + Interval::new(72873, 72886), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73025), + Interval::new(73027, 73027), + Interval::new(73030, 73031), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73110), + Interval::new(73112, 73112), + Interval::new(73136, 73179), + Interval::new(73440, 73462), + Interval::new(73472, 73488), + Interval::new(73490, 73530), + Interval::new(73534, 73536), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74752, 74862), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78913, 78918), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90414), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92784, 92862), + Interval::new(92880, 92909), + Interval::new(92928, 92975), + Interval::new(92992, 92995), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93548), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94031, 94087), + Interval::new(94095, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94179), + Interval::new(94192, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113822, 113822), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(122928, 122989), + Interval::new(123023, 123023), + Interval::new(123136, 123180), + Interval::new(123191, 123197), + Interval::new(123214, 123214), + Interval::new(123536, 123565), + Interval::new(123584, 123627), + Interval::new(124112, 124139), + Interval::new(124368, 124397), + Interval::new(124400, 124400), + Interval::new(124608, 124638), + Interval::new(124640, 124661), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125184, 125251), + Interval::new(125255, 125255), + Interval::new(125259, 125259), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(127280, 127305), + Interval::new(127312, 127337), + Interval::new(127344, 127369), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'Alphabetic' Unicode property. +pub(crate) fn alphabetic_ranges() -> &'static [Interval] { + &ALPHABETIC +} + +const CASE_IGNORABLE: [Interval; 464] = [ + Interval::new(39, 39), + Interval::new(46, 46), + Interval::new(58, 58), + Interval::new(94, 94), + Interval::new(96, 96), + Interval::new(168, 168), + Interval::new(173, 173), + Interval::new(175, 175), + Interval::new(180, 180), + Interval::new(183, 184), + Interval::new(688, 879), + Interval::new(884, 885), + Interval::new(890, 890), + Interval::new(900, 901), + Interval::new(903, 903), + Interval::new(1155, 1161), + Interval::new(1369, 1369), + Interval::new(1375, 1375), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1524, 1524), + Interval::new(1536, 1541), + Interval::new(1552, 1562), + Interval::new(1564, 1564), + Interval::new(1600, 1600), + Interval::new(1611, 1631), + Interval::new(1648, 1648), + Interval::new(1750, 1757), + Interval::new(1759, 1768), + Interval::new(1770, 1773), + Interval::new(1807, 1807), + Interval::new(1809, 1809), + Interval::new(1840, 1866), + Interval::new(1958, 1968), + Interval::new(2027, 2037), + Interval::new(2042, 2042), + Interval::new(2045, 2045), + Interval::new(2070, 2093), + Interval::new(2137, 2139), + Interval::new(2184, 2184), + Interval::new(2192, 2193), + Interval::new(2199, 2207), + Interval::new(2249, 2306), + Interval::new(2362, 2362), + Interval::new(2364, 2364), + Interval::new(2369, 2376), + Interval::new(2381, 2381), + Interval::new(2385, 2391), + Interval::new(2402, 2403), + Interval::new(2417, 2417), + Interval::new(2433, 2433), + Interval::new(2492, 2492), + Interval::new(2497, 2500), + Interval::new(2509, 2509), + Interval::new(2530, 2531), + Interval::new(2558, 2558), + Interval::new(2561, 2562), + Interval::new(2620, 2620), + Interval::new(2625, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2672, 2673), + Interval::new(2677, 2677), + Interval::new(2689, 2690), + Interval::new(2748, 2748), + Interval::new(2753, 2757), + Interval::new(2759, 2760), + Interval::new(2765, 2765), + Interval::new(2786, 2787), + Interval::new(2810, 2815), + Interval::new(2817, 2817), + Interval::new(2876, 2876), + Interval::new(2879, 2879), + Interval::new(2881, 2884), + Interval::new(2893, 2893), + Interval::new(2901, 2902), + Interval::new(2914, 2915), + Interval::new(2946, 2946), + Interval::new(3008, 3008), + Interval::new(3021, 3021), + Interval::new(3072, 3072), + Interval::new(3076, 3076), + Interval::new(3132, 3132), + Interval::new(3134, 3136), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3170, 3171), + Interval::new(3201, 3201), + Interval::new(3260, 3260), + Interval::new(3263, 3263), + Interval::new(3270, 3270), + Interval::new(3276, 3277), + Interval::new(3298, 3299), + Interval::new(3328, 3329), + Interval::new(3387, 3388), + Interval::new(3393, 3396), + Interval::new(3405, 3405), + Interval::new(3426, 3427), + Interval::new(3457, 3457), + Interval::new(3530, 3530), + Interval::new(3538, 3540), + Interval::new(3542, 3542), + Interval::new(3633, 3633), + Interval::new(3636, 3642), + Interval::new(3654, 3662), + Interval::new(3761, 3761), + Interval::new(3764, 3772), + Interval::new(3782, 3782), + Interval::new(3784, 3790), + Interval::new(3864, 3865), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3953, 3966), + Interval::new(3968, 3972), + Interval::new(3974, 3975), + Interval::new(3981, 3991), + Interval::new(3993, 4028), + Interval::new(4038, 4038), + Interval::new(4141, 4144), + Interval::new(4146, 4151), + Interval::new(4153, 4154), + Interval::new(4157, 4158), + Interval::new(4184, 4185), + Interval::new(4190, 4192), + Interval::new(4209, 4212), + Interval::new(4226, 4226), + Interval::new(4229, 4230), + Interval::new(4237, 4237), + Interval::new(4253, 4253), + Interval::new(4348, 4348), + Interval::new(4957, 4959), + Interval::new(5906, 5908), + Interval::new(5938, 5939), + Interval::new(5970, 5971), + Interval::new(6002, 6003), + Interval::new(6068, 6069), + Interval::new(6071, 6077), + Interval::new(6086, 6086), + Interval::new(6089, 6099), + Interval::new(6103, 6103), + Interval::new(6109, 6109), + Interval::new(6155, 6159), + Interval::new(6211, 6211), + Interval::new(6277, 6278), + Interval::new(6313, 6313), + Interval::new(6432, 6434), + Interval::new(6439, 6440), + Interval::new(6450, 6450), + Interval::new(6457, 6459), + Interval::new(6679, 6680), + Interval::new(6683, 6683), + Interval::new(6742, 6742), + Interval::new(6744, 6750), + Interval::new(6752, 6752), + Interval::new(6754, 6754), + Interval::new(6757, 6764), + Interval::new(6771, 6780), + Interval::new(6783, 6783), + Interval::new(6823, 6823), + Interval::new(6832, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6915), + Interval::new(6964, 6964), + Interval::new(6966, 6970), + Interval::new(6972, 6972), + Interval::new(6978, 6978), + Interval::new(7019, 7027), + Interval::new(7040, 7041), + Interval::new(7074, 7077), + Interval::new(7080, 7081), + Interval::new(7083, 7085), + Interval::new(7142, 7142), + Interval::new(7144, 7145), + Interval::new(7149, 7149), + Interval::new(7151, 7153), + Interval::new(7212, 7219), + Interval::new(7222, 7223), + Interval::new(7288, 7293), + Interval::new(7376, 7378), + Interval::new(7380, 7392), + Interval::new(7394, 7400), + Interval::new(7405, 7405), + Interval::new(7412, 7412), + Interval::new(7416, 7417), + Interval::new(7468, 7530), + Interval::new(7544, 7544), + Interval::new(7579, 7679), + Interval::new(8125, 8125), + Interval::new(8127, 8129), + Interval::new(8141, 8143), + Interval::new(8157, 8159), + Interval::new(8173, 8175), + Interval::new(8189, 8190), + Interval::new(8203, 8207), + Interval::new(8216, 8217), + Interval::new(8228, 8228), + Interval::new(8231, 8231), + Interval::new(8234, 8238), + Interval::new(8288, 8292), + Interval::new(8294, 8303), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8400, 8432), + Interval::new(11388, 11389), + Interval::new(11503, 11505), + Interval::new(11631, 11631), + Interval::new(11647, 11647), + Interval::new(11744, 11775), + Interval::new(11823, 11823), + Interval::new(12293, 12293), + Interval::new(12330, 12333), + Interval::new(12337, 12341), + Interval::new(12347, 12347), + Interval::new(12441, 12446), + Interval::new(12540, 12542), + Interval::new(40981, 40981), + Interval::new(42232, 42237), + Interval::new(42508, 42508), + Interval::new(42607, 42610), + Interval::new(42612, 42621), + Interval::new(42623, 42623), + Interval::new(42652, 42655), + Interval::new(42736, 42737), + Interval::new(42752, 42785), + Interval::new(42864, 42864), + Interval::new(42888, 42890), + Interval::new(42993, 42996), + Interval::new(43000, 43001), + Interval::new(43010, 43010), + Interval::new(43014, 43014), + Interval::new(43019, 43019), + Interval::new(43045, 43046), + Interval::new(43052, 43052), + Interval::new(43204, 43205), + Interval::new(43232, 43249), + Interval::new(43263, 43263), + Interval::new(43302, 43309), + Interval::new(43335, 43345), + Interval::new(43392, 43394), + Interval::new(43443, 43443), + Interval::new(43446, 43449), + Interval::new(43452, 43453), + Interval::new(43471, 43471), + Interval::new(43493, 43494), + Interval::new(43561, 43566), + Interval::new(43569, 43570), + Interval::new(43573, 43574), + Interval::new(43587, 43587), + Interval::new(43596, 43596), + Interval::new(43632, 43632), + Interval::new(43644, 43644), + Interval::new(43696, 43696), + Interval::new(43698, 43700), + Interval::new(43703, 43704), + Interval::new(43710, 43711), + Interval::new(43713, 43713), + Interval::new(43741, 43741), + Interval::new(43756, 43757), + Interval::new(43763, 43764), + Interval::new(43766, 43766), + Interval::new(43867, 43871), + Interval::new(43881, 43883), + Interval::new(44005, 44005), + Interval::new(44008, 44008), + Interval::new(44013, 44013), + Interval::new(64286, 64286), + Interval::new(64434, 64450), + Interval::new(65024, 65039), + Interval::new(65043, 65043), + Interval::new(65056, 65071), + Interval::new(65106, 65106), + Interval::new(65109, 65109), + Interval::new(65279, 65279), + Interval::new(65287, 65287), + Interval::new(65294, 65294), + Interval::new(65306, 65306), + Interval::new(65342, 65342), + Interval::new(65344, 65344), + Interval::new(65392, 65392), + Interval::new(65438, 65439), + Interval::new(65507, 65507), + Interval::new(65529, 65531), + Interval::new(66045, 66045), + Interval::new(66272, 66272), + Interval::new(66422, 66426), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(68097, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68111), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68325, 68326), + Interval::new(68900, 68903), + Interval::new(68942, 68942), + Interval::new(68969, 68973), + Interval::new(68975, 68975), + Interval::new(69291, 69292), + Interval::new(69317, 69317), + Interval::new(69370, 69375), + Interval::new(69446, 69456), + Interval::new(69506, 69509), + Interval::new(69633, 69633), + Interval::new(69688, 69702), + Interval::new(69744, 69744), + Interval::new(69747, 69748), + Interval::new(69759, 69761), + Interval::new(69811, 69814), + Interval::new(69817, 69818), + Interval::new(69821, 69821), + Interval::new(69826, 69826), + Interval::new(69837, 69837), + Interval::new(69888, 69890), + Interval::new(69927, 69931), + Interval::new(69933, 69940), + Interval::new(70003, 70003), + Interval::new(70016, 70017), + Interval::new(70070, 70078), + Interval::new(70089, 70092), + Interval::new(70095, 70095), + Interval::new(70191, 70193), + Interval::new(70196, 70196), + Interval::new(70198, 70199), + Interval::new(70206, 70206), + Interval::new(70209, 70209), + Interval::new(70367, 70367), + Interval::new(70371, 70378), + Interval::new(70400, 70401), + Interval::new(70459, 70460), + Interval::new(70464, 70464), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70587, 70592), + Interval::new(70606, 70606), + Interval::new(70608, 70608), + Interval::new(70610, 70610), + Interval::new(70625, 70626), + Interval::new(70712, 70719), + Interval::new(70722, 70724), + Interval::new(70726, 70726), + Interval::new(70750, 70750), + Interval::new(70835, 70840), + Interval::new(70842, 70842), + Interval::new(70847, 70848), + Interval::new(70850, 70851), + Interval::new(71090, 71093), + Interval::new(71100, 71101), + Interval::new(71103, 71104), + Interval::new(71132, 71133), + Interval::new(71219, 71226), + Interval::new(71229, 71229), + Interval::new(71231, 71232), + Interval::new(71339, 71339), + Interval::new(71341, 71341), + Interval::new(71344, 71349), + Interval::new(71351, 71351), + Interval::new(71453, 71453), + Interval::new(71455, 71455), + Interval::new(71458, 71461), + Interval::new(71463, 71467), + Interval::new(71727, 71735), + Interval::new(71737, 71738), + Interval::new(71995, 71996), + Interval::new(71998, 71998), + Interval::new(72003, 72003), + Interval::new(72148, 72151), + Interval::new(72154, 72155), + Interval::new(72160, 72160), + Interval::new(72193, 72202), + Interval::new(72243, 72248), + Interval::new(72251, 72254), + Interval::new(72263, 72263), + Interval::new(72273, 72278), + Interval::new(72281, 72283), + Interval::new(72330, 72342), + Interval::new(72344, 72345), + Interval::new(72544, 72544), + Interval::new(72546, 72548), + Interval::new(72550, 72550), + Interval::new(72752, 72758), + Interval::new(72760, 72765), + Interval::new(72767, 72767), + Interval::new(72850, 72871), + Interval::new(72874, 72880), + Interval::new(72882, 72883), + Interval::new(72885, 72886), + Interval::new(73009, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73029), + Interval::new(73031, 73031), + Interval::new(73104, 73105), + Interval::new(73109, 73109), + Interval::new(73111, 73111), + Interval::new(73177, 73177), + Interval::new(73459, 73460), + Interval::new(73472, 73473), + Interval::new(73526, 73530), + Interval::new(73536, 73536), + Interval::new(73538, 73538), + Interval::new(73562, 73562), + Interval::new(78896, 78912), + Interval::new(78919, 78933), + Interval::new(90398, 90409), + Interval::new(90413, 90415), + Interval::new(92912, 92916), + Interval::new(92976, 92982), + Interval::new(92992, 92995), + Interval::new(93504, 93506), + Interval::new(93547, 93548), + Interval::new(94031, 94031), + Interval::new(94095, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94180), + Interval::new(94194, 94195), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(113821, 113822), + Interval::new(113824, 113827), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119143, 119145), + Interval::new(119155, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(119362, 119364), + Interval::new(121344, 121398), + Interval::new(121403, 121452), + Interval::new(121461, 121461), + Interval::new(121476, 121476), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(122928, 122989), + Interval::new(123023, 123023), + Interval::new(123184, 123197), + Interval::new(123566, 123566), + Interval::new(123628, 123631), + Interval::new(124139, 124143), + Interval::new(124398, 124399), + Interval::new(124643, 124643), + Interval::new(124646, 124646), + Interval::new(124654, 124655), + Interval::new(124661, 124661), + Interval::new(124671, 124671), + Interval::new(125136, 125142), + Interval::new(125252, 125259), + Interval::new(127995, 127999), + Interval::new(917505, 917505), + Interval::new(917536, 917631), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'Case_Ignorable' Unicode property. +pub(crate) fn case_ignorable_ranges() -> &'static [Interval] { + &CASE_IGNORABLE +} + +const CASED: [Interval; 158] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 442), + Interval::new(444, 447), + Interval::new(452, 659), + Interval::new(662, 696), + Interval::new(704, 705), + Interval::new(736, 740), + Interval::new(837, 837), + Interval::new(880, 883), + Interval::new(886, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1376, 1416), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4351), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7424, 7615), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8473, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8495, 8500), + Interval::new(8505, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8544, 8575), + Interval::new(8579, 8580), + Interval::new(9398, 9449), + Interval::new(11264, 11492), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42560, 42605), + Interval::new(42624, 42653), + Interval::new(42786, 42887), + Interval::new(42891, 42894), + Interval::new(42896, 42972), + Interval::new(42993, 42998), + Interval::new(43000, 43002), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(66560, 66639), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67456, 67456), + Interval::new(67459, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68944, 68965), + Interval::new(68976, 68997), + Interval::new(71840, 71903), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(122624, 122633), + Interval::new(122635, 122654), + Interval::new(122661, 122666), + Interval::new(122928, 122989), + Interval::new(125184, 125251), + Interval::new(127280, 127305), + Interval::new(127312, 127337), + Interval::new(127344, 127369), +]; + +/// Return the code point ranges of the 'Cased' Unicode property. +pub(crate) fn cased_ranges() -> &'static [Interval] { + &CASED +} + +const CHANGES_WHEN_CASEFOLDED: [Interval; 630] = [ + Interval::new(65, 90), + Interval::new(181, 181), + Interval::new(192, 214), + Interval::new(216, 223), + Interval::new(256, 256), + Interval::new(258, 258), + Interval::new(260, 260), + Interval::new(262, 262), + Interval::new(264, 264), + Interval::new(266, 266), + Interval::new(268, 268), + Interval::new(270, 270), + Interval::new(272, 272), + Interval::new(274, 274), + Interval::new(276, 276), + Interval::new(278, 278), + Interval::new(280, 280), + Interval::new(282, 282), + Interval::new(284, 284), + Interval::new(286, 286), + Interval::new(288, 288), + Interval::new(290, 290), + Interval::new(292, 292), + Interval::new(294, 294), + Interval::new(296, 296), + Interval::new(298, 298), + Interval::new(300, 300), + Interval::new(302, 302), + Interval::new(304, 304), + Interval::new(306, 306), + Interval::new(308, 308), + Interval::new(310, 310), + Interval::new(313, 313), + Interval::new(315, 315), + Interval::new(317, 317), + Interval::new(319, 319), + Interval::new(321, 321), + Interval::new(323, 323), + Interval::new(325, 325), + Interval::new(327, 327), + Interval::new(329, 330), + Interval::new(332, 332), + Interval::new(334, 334), + Interval::new(336, 336), + Interval::new(338, 338), + Interval::new(340, 340), + Interval::new(342, 342), + Interval::new(344, 344), + Interval::new(346, 346), + Interval::new(348, 348), + Interval::new(350, 350), + Interval::new(352, 352), + Interval::new(354, 354), + Interval::new(356, 356), + Interval::new(358, 358), + Interval::new(360, 360), + Interval::new(362, 362), + Interval::new(364, 364), + Interval::new(366, 366), + Interval::new(368, 368), + Interval::new(370, 370), + Interval::new(372, 372), + Interval::new(374, 374), + Interval::new(376, 377), + Interval::new(379, 379), + Interval::new(381, 381), + Interval::new(383, 383), + Interval::new(385, 386), + Interval::new(388, 388), + Interval::new(390, 391), + Interval::new(393, 395), + Interval::new(398, 401), + Interval::new(403, 404), + Interval::new(406, 408), + Interval::new(412, 413), + Interval::new(415, 416), + Interval::new(418, 418), + Interval::new(420, 420), + Interval::new(422, 423), + Interval::new(425, 425), + Interval::new(428, 428), + Interval::new(430, 431), + Interval::new(433, 435), + Interval::new(437, 437), + Interval::new(439, 440), + Interval::new(444, 444), + Interval::new(452, 453), + Interval::new(455, 456), + Interval::new(458, 459), + Interval::new(461, 461), + Interval::new(463, 463), + Interval::new(465, 465), + Interval::new(467, 467), + Interval::new(469, 469), + Interval::new(471, 471), + Interval::new(473, 473), + Interval::new(475, 475), + Interval::new(478, 478), + Interval::new(480, 480), + Interval::new(482, 482), + Interval::new(484, 484), + Interval::new(486, 486), + Interval::new(488, 488), + Interval::new(490, 490), + Interval::new(492, 492), + Interval::new(494, 494), + Interval::new(497, 498), + Interval::new(500, 500), + Interval::new(502, 504), + Interval::new(506, 506), + Interval::new(508, 508), + Interval::new(510, 510), + Interval::new(512, 512), + Interval::new(514, 514), + Interval::new(516, 516), + Interval::new(518, 518), + Interval::new(520, 520), + Interval::new(522, 522), + Interval::new(524, 524), + Interval::new(526, 526), + Interval::new(528, 528), + Interval::new(530, 530), + Interval::new(532, 532), + Interval::new(534, 534), + Interval::new(536, 536), + Interval::new(538, 538), + Interval::new(540, 540), + Interval::new(542, 542), + Interval::new(544, 544), + Interval::new(546, 546), + Interval::new(548, 548), + Interval::new(550, 550), + Interval::new(552, 552), + Interval::new(554, 554), + Interval::new(556, 556), + Interval::new(558, 558), + Interval::new(560, 560), + Interval::new(562, 562), + Interval::new(570, 571), + Interval::new(573, 574), + Interval::new(577, 577), + Interval::new(579, 582), + Interval::new(584, 584), + Interval::new(586, 586), + Interval::new(588, 588), + Interval::new(590, 590), + Interval::new(837, 837), + Interval::new(880, 880), + Interval::new(882, 882), + Interval::new(886, 886), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 911), + Interval::new(913, 929), + Interval::new(931, 939), + Interval::new(962, 962), + Interval::new(975, 977), + Interval::new(981, 982), + Interval::new(984, 984), + Interval::new(986, 986), + Interval::new(988, 988), + Interval::new(990, 990), + Interval::new(992, 992), + Interval::new(994, 994), + Interval::new(996, 996), + Interval::new(998, 998), + Interval::new(1000, 1000), + Interval::new(1002, 1002), + Interval::new(1004, 1004), + Interval::new(1006, 1006), + Interval::new(1008, 1009), + Interval::new(1012, 1013), + Interval::new(1015, 1015), + Interval::new(1017, 1018), + Interval::new(1021, 1071), + Interval::new(1120, 1120), + Interval::new(1122, 1122), + Interval::new(1124, 1124), + Interval::new(1126, 1126), + Interval::new(1128, 1128), + Interval::new(1130, 1130), + Interval::new(1132, 1132), + Interval::new(1134, 1134), + Interval::new(1136, 1136), + Interval::new(1138, 1138), + Interval::new(1140, 1140), + Interval::new(1142, 1142), + Interval::new(1144, 1144), + Interval::new(1146, 1146), + Interval::new(1148, 1148), + Interval::new(1150, 1150), + Interval::new(1152, 1152), + Interval::new(1162, 1162), + Interval::new(1164, 1164), + Interval::new(1166, 1166), + Interval::new(1168, 1168), + Interval::new(1170, 1170), + Interval::new(1172, 1172), + Interval::new(1174, 1174), + Interval::new(1176, 1176), + Interval::new(1178, 1178), + Interval::new(1180, 1180), + Interval::new(1182, 1182), + Interval::new(1184, 1184), + Interval::new(1186, 1186), + Interval::new(1188, 1188), + Interval::new(1190, 1190), + Interval::new(1192, 1192), + Interval::new(1194, 1194), + Interval::new(1196, 1196), + Interval::new(1198, 1198), + Interval::new(1200, 1200), + Interval::new(1202, 1202), + Interval::new(1204, 1204), + Interval::new(1206, 1206), + Interval::new(1208, 1208), + Interval::new(1210, 1210), + Interval::new(1212, 1212), + Interval::new(1214, 1214), + Interval::new(1216, 1217), + Interval::new(1219, 1219), + Interval::new(1221, 1221), + Interval::new(1223, 1223), + Interval::new(1225, 1225), + Interval::new(1227, 1227), + Interval::new(1229, 1229), + Interval::new(1232, 1232), + Interval::new(1234, 1234), + Interval::new(1236, 1236), + Interval::new(1238, 1238), + Interval::new(1240, 1240), + Interval::new(1242, 1242), + Interval::new(1244, 1244), + Interval::new(1246, 1246), + Interval::new(1248, 1248), + Interval::new(1250, 1250), + Interval::new(1252, 1252), + Interval::new(1254, 1254), + Interval::new(1256, 1256), + Interval::new(1258, 1258), + Interval::new(1260, 1260), + Interval::new(1262, 1262), + Interval::new(1264, 1264), + Interval::new(1266, 1266), + Interval::new(1268, 1268), + Interval::new(1270, 1270), + Interval::new(1272, 1272), + Interval::new(1274, 1274), + Interval::new(1276, 1276), + Interval::new(1278, 1278), + Interval::new(1280, 1280), + Interval::new(1282, 1282), + Interval::new(1284, 1284), + Interval::new(1286, 1286), + Interval::new(1288, 1288), + Interval::new(1290, 1290), + Interval::new(1292, 1292), + Interval::new(1294, 1294), + Interval::new(1296, 1296), + Interval::new(1298, 1298), + Interval::new(1300, 1300), + Interval::new(1302, 1302), + Interval::new(1304, 1304), + Interval::new(1306, 1306), + Interval::new(1308, 1308), + Interval::new(1310, 1310), + Interval::new(1312, 1312), + Interval::new(1314, 1314), + Interval::new(1316, 1316), + Interval::new(1318, 1318), + Interval::new(1320, 1320), + Interval::new(1322, 1322), + Interval::new(1324, 1324), + Interval::new(1326, 1326), + Interval::new(1329, 1366), + Interval::new(1415, 1415), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(5112, 5117), + Interval::new(7296, 7305), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7680, 7680), + Interval::new(7682, 7682), + Interval::new(7684, 7684), + Interval::new(7686, 7686), + Interval::new(7688, 7688), + Interval::new(7690, 7690), + Interval::new(7692, 7692), + Interval::new(7694, 7694), + Interval::new(7696, 7696), + Interval::new(7698, 7698), + Interval::new(7700, 7700), + Interval::new(7702, 7702), + Interval::new(7704, 7704), + Interval::new(7706, 7706), + Interval::new(7708, 7708), + Interval::new(7710, 7710), + Interval::new(7712, 7712), + Interval::new(7714, 7714), + Interval::new(7716, 7716), + Interval::new(7718, 7718), + Interval::new(7720, 7720), + Interval::new(7722, 7722), + Interval::new(7724, 7724), + Interval::new(7726, 7726), + Interval::new(7728, 7728), + Interval::new(7730, 7730), + Interval::new(7732, 7732), + Interval::new(7734, 7734), + Interval::new(7736, 7736), + Interval::new(7738, 7738), + Interval::new(7740, 7740), + Interval::new(7742, 7742), + Interval::new(7744, 7744), + Interval::new(7746, 7746), + Interval::new(7748, 7748), + Interval::new(7750, 7750), + Interval::new(7752, 7752), + Interval::new(7754, 7754), + Interval::new(7756, 7756), + Interval::new(7758, 7758), + Interval::new(7760, 7760), + Interval::new(7762, 7762), + Interval::new(7764, 7764), + Interval::new(7766, 7766), + Interval::new(7768, 7768), + Interval::new(7770, 7770), + Interval::new(7772, 7772), + Interval::new(7774, 7774), + Interval::new(7776, 7776), + Interval::new(7778, 7778), + Interval::new(7780, 7780), + Interval::new(7782, 7782), + Interval::new(7784, 7784), + Interval::new(7786, 7786), + Interval::new(7788, 7788), + Interval::new(7790, 7790), + Interval::new(7792, 7792), + Interval::new(7794, 7794), + Interval::new(7796, 7796), + Interval::new(7798, 7798), + Interval::new(7800, 7800), + Interval::new(7802, 7802), + Interval::new(7804, 7804), + Interval::new(7806, 7806), + Interval::new(7808, 7808), + Interval::new(7810, 7810), + Interval::new(7812, 7812), + Interval::new(7814, 7814), + Interval::new(7816, 7816), + Interval::new(7818, 7818), + Interval::new(7820, 7820), + Interval::new(7822, 7822), + Interval::new(7824, 7824), + Interval::new(7826, 7826), + Interval::new(7828, 7828), + Interval::new(7834, 7835), + Interval::new(7838, 7838), + Interval::new(7840, 7840), + Interval::new(7842, 7842), + Interval::new(7844, 7844), + Interval::new(7846, 7846), + Interval::new(7848, 7848), + Interval::new(7850, 7850), + Interval::new(7852, 7852), + Interval::new(7854, 7854), + Interval::new(7856, 7856), + Interval::new(7858, 7858), + Interval::new(7860, 7860), + Interval::new(7862, 7862), + Interval::new(7864, 7864), + Interval::new(7866, 7866), + Interval::new(7868, 7868), + Interval::new(7870, 7870), + Interval::new(7872, 7872), + Interval::new(7874, 7874), + Interval::new(7876, 7876), + Interval::new(7878, 7878), + Interval::new(7880, 7880), + Interval::new(7882, 7882), + Interval::new(7884, 7884), + Interval::new(7886, 7886), + Interval::new(7888, 7888), + Interval::new(7890, 7890), + Interval::new(7892, 7892), + Interval::new(7894, 7894), + Interval::new(7896, 7896), + Interval::new(7898, 7898), + Interval::new(7900, 7900), + Interval::new(7902, 7902), + Interval::new(7904, 7904), + Interval::new(7906, 7906), + Interval::new(7908, 7908), + Interval::new(7910, 7910), + Interval::new(7912, 7912), + Interval::new(7914, 7914), + Interval::new(7916, 7916), + Interval::new(7918, 7918), + Interval::new(7920, 7920), + Interval::new(7922, 7922), + Interval::new(7924, 7924), + Interval::new(7926, 7926), + Interval::new(7928, 7928), + Interval::new(7930, 7930), + Interval::new(7932, 7932), + Interval::new(7934, 7934), + Interval::new(7944, 7951), + Interval::new(7960, 7965), + Interval::new(7976, 7983), + Interval::new(7992, 7999), + Interval::new(8008, 8013), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8031), + Interval::new(8040, 8047), + Interval::new(8064, 8111), + Interval::new(8114, 8116), + Interval::new(8119, 8124), + Interval::new(8130, 8132), + Interval::new(8135, 8140), + Interval::new(8152, 8155), + Interval::new(8168, 8172), + Interval::new(8178, 8180), + Interval::new(8183, 8188), + Interval::new(8486, 8486), + Interval::new(8490, 8491), + Interval::new(8498, 8498), + Interval::new(8544, 8559), + Interval::new(8579, 8579), + Interval::new(9398, 9423), + Interval::new(11264, 11311), + Interval::new(11360, 11360), + Interval::new(11362, 11364), + Interval::new(11367, 11367), + Interval::new(11369, 11369), + Interval::new(11371, 11371), + Interval::new(11373, 11376), + Interval::new(11378, 11378), + Interval::new(11381, 11381), + Interval::new(11390, 11392), + Interval::new(11394, 11394), + Interval::new(11396, 11396), + Interval::new(11398, 11398), + Interval::new(11400, 11400), + Interval::new(11402, 11402), + Interval::new(11404, 11404), + Interval::new(11406, 11406), + Interval::new(11408, 11408), + Interval::new(11410, 11410), + Interval::new(11412, 11412), + Interval::new(11414, 11414), + Interval::new(11416, 11416), + Interval::new(11418, 11418), + Interval::new(11420, 11420), + Interval::new(11422, 11422), + Interval::new(11424, 11424), + Interval::new(11426, 11426), + Interval::new(11428, 11428), + Interval::new(11430, 11430), + Interval::new(11432, 11432), + Interval::new(11434, 11434), + Interval::new(11436, 11436), + Interval::new(11438, 11438), + Interval::new(11440, 11440), + Interval::new(11442, 11442), + Interval::new(11444, 11444), + Interval::new(11446, 11446), + Interval::new(11448, 11448), + Interval::new(11450, 11450), + Interval::new(11452, 11452), + Interval::new(11454, 11454), + Interval::new(11456, 11456), + Interval::new(11458, 11458), + Interval::new(11460, 11460), + Interval::new(11462, 11462), + Interval::new(11464, 11464), + Interval::new(11466, 11466), + Interval::new(11468, 11468), + Interval::new(11470, 11470), + Interval::new(11472, 11472), + Interval::new(11474, 11474), + Interval::new(11476, 11476), + Interval::new(11478, 11478), + Interval::new(11480, 11480), + Interval::new(11482, 11482), + Interval::new(11484, 11484), + Interval::new(11486, 11486), + Interval::new(11488, 11488), + Interval::new(11490, 11490), + Interval::new(11499, 11499), + Interval::new(11501, 11501), + Interval::new(11506, 11506), + Interval::new(42560, 42560), + Interval::new(42562, 42562), + Interval::new(42564, 42564), + Interval::new(42566, 42566), + Interval::new(42568, 42568), + Interval::new(42570, 42570), + Interval::new(42572, 42572), + Interval::new(42574, 42574), + Interval::new(42576, 42576), + Interval::new(42578, 42578), + Interval::new(42580, 42580), + Interval::new(42582, 42582), + Interval::new(42584, 42584), + Interval::new(42586, 42586), + Interval::new(42588, 42588), + Interval::new(42590, 42590), + Interval::new(42592, 42592), + Interval::new(42594, 42594), + Interval::new(42596, 42596), + Interval::new(42598, 42598), + Interval::new(42600, 42600), + Interval::new(42602, 42602), + Interval::new(42604, 42604), + Interval::new(42624, 42624), + Interval::new(42626, 42626), + Interval::new(42628, 42628), + Interval::new(42630, 42630), + Interval::new(42632, 42632), + Interval::new(42634, 42634), + Interval::new(42636, 42636), + Interval::new(42638, 42638), + Interval::new(42640, 42640), + Interval::new(42642, 42642), + Interval::new(42644, 42644), + Interval::new(42646, 42646), + Interval::new(42648, 42648), + Interval::new(42650, 42650), + Interval::new(42786, 42786), + Interval::new(42788, 42788), + Interval::new(42790, 42790), + Interval::new(42792, 42792), + Interval::new(42794, 42794), + Interval::new(42796, 42796), + Interval::new(42798, 42798), + Interval::new(42802, 42802), + Interval::new(42804, 42804), + Interval::new(42806, 42806), + Interval::new(42808, 42808), + Interval::new(42810, 42810), + Interval::new(42812, 42812), + Interval::new(42814, 42814), + Interval::new(42816, 42816), + Interval::new(42818, 42818), + Interval::new(42820, 42820), + Interval::new(42822, 42822), + Interval::new(42824, 42824), + Interval::new(42826, 42826), + Interval::new(42828, 42828), + Interval::new(42830, 42830), + Interval::new(42832, 42832), + Interval::new(42834, 42834), + Interval::new(42836, 42836), + Interval::new(42838, 42838), + Interval::new(42840, 42840), + Interval::new(42842, 42842), + Interval::new(42844, 42844), + Interval::new(42846, 42846), + Interval::new(42848, 42848), + Interval::new(42850, 42850), + Interval::new(42852, 42852), + Interval::new(42854, 42854), + Interval::new(42856, 42856), + Interval::new(42858, 42858), + Interval::new(42860, 42860), + Interval::new(42862, 42862), + Interval::new(42873, 42873), + Interval::new(42875, 42875), + Interval::new(42877, 42878), + Interval::new(42880, 42880), + Interval::new(42882, 42882), + Interval::new(42884, 42884), + Interval::new(42886, 42886), + Interval::new(42891, 42891), + Interval::new(42893, 42893), + Interval::new(42896, 42896), + Interval::new(42898, 42898), + Interval::new(42902, 42902), + Interval::new(42904, 42904), + Interval::new(42906, 42906), + Interval::new(42908, 42908), + Interval::new(42910, 42910), + Interval::new(42912, 42912), + Interval::new(42914, 42914), + Interval::new(42916, 42916), + Interval::new(42918, 42918), + Interval::new(42920, 42920), + Interval::new(42922, 42926), + Interval::new(42928, 42932), + Interval::new(42934, 42934), + Interval::new(42936, 42936), + Interval::new(42938, 42938), + Interval::new(42940, 42940), + Interval::new(42942, 42942), + Interval::new(42944, 42944), + Interval::new(42946, 42946), + Interval::new(42948, 42951), + Interval::new(42953, 42953), + Interval::new(42955, 42956), + Interval::new(42958, 42958), + Interval::new(42960, 42960), + Interval::new(42962, 42962), + Interval::new(42964, 42964), + Interval::new(42966, 42966), + Interval::new(42968, 42968), + Interval::new(42970, 42970), + Interval::new(42972, 42972), + Interval::new(42997, 42997), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65313, 65338), + Interval::new(66560, 66599), + Interval::new(66736, 66771), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(68736, 68786), + Interval::new(68944, 68965), + Interval::new(71840, 71871), + Interval::new(93760, 93791), + Interval::new(93856, 93880), + Interval::new(125184, 125217), +]; + +/// Return the code point ranges of the 'Changes_When_Casefolded' Unicode property. +pub(crate) fn changes_when_casefolded_ranges() -> &'static [Interval] { + &CHANGES_WHEN_CASEFOLDED +} + +const CHANGES_WHEN_CASEMAPPED: [Interval; 131] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(181, 181), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 311), + Interval::new(313, 396), + Interval::new(398, 425), + Interval::new(428, 441), + Interval::new(444, 445), + Interval::new(447, 447), + Interval::new(452, 544), + Interval::new(546, 563), + Interval::new(570, 596), + Interval::new(598, 599), + Interval::new(601, 601), + Interval::new(603, 604), + Interval::new(608, 609), + Interval::new(611, 614), + Interval::new(616, 620), + Interval::new(623, 623), + Interval::new(625, 626), + Interval::new(629, 629), + Interval::new(637, 637), + Interval::new(640, 640), + Interval::new(642, 643), + Interval::new(647, 652), + Interval::new(658, 658), + Interval::new(669, 670), + Interval::new(837, 837), + Interval::new(880, 883), + Interval::new(886, 887), + Interval::new(891, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 977), + Interval::new(981, 1013), + Interval::new(1015, 1019), + Interval::new(1021, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1377, 1415), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4349, 4351), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7545, 7545), + Interval::new(7549, 7549), + Interval::new(7566, 7566), + Interval::new(7680, 7835), + Interval::new(7838, 7838), + Interval::new(7840, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8486, 8486), + Interval::new(8490, 8491), + Interval::new(8498, 8498), + Interval::new(8526, 8526), + Interval::new(8544, 8575), + Interval::new(8579, 8580), + Interval::new(9398, 9449), + Interval::new(11264, 11376), + Interval::new(11378, 11379), + Interval::new(11381, 11382), + Interval::new(11390, 11491), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42560, 42605), + Interval::new(42624, 42651), + Interval::new(42786, 42799), + Interval::new(42802, 42863), + Interval::new(42873, 42887), + Interval::new(42891, 42893), + Interval::new(42896, 42900), + Interval::new(42902, 42926), + Interval::new(42928, 42972), + Interval::new(42997, 42998), + Interval::new(43859, 43859), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(66560, 66639), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68944, 68965), + Interval::new(68976, 68997), + Interval::new(71840, 71903), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(125184, 125251), +]; + +/// Return the code point ranges of the 'Changes_When_Casemapped' Unicode property. +pub(crate) fn changes_when_casemapped_ranges() -> &'static [Interval] { + &CHANGES_WHEN_CASEMAPPED +} + +const CHANGES_WHEN_LOWERCASED: [Interval; 618] = [ + Interval::new(65, 90), + Interval::new(192, 214), + Interval::new(216, 222), + Interval::new(256, 256), + Interval::new(258, 258), + Interval::new(260, 260), + Interval::new(262, 262), + Interval::new(264, 264), + Interval::new(266, 266), + Interval::new(268, 268), + Interval::new(270, 270), + Interval::new(272, 272), + Interval::new(274, 274), + Interval::new(276, 276), + Interval::new(278, 278), + Interval::new(280, 280), + Interval::new(282, 282), + Interval::new(284, 284), + Interval::new(286, 286), + Interval::new(288, 288), + Interval::new(290, 290), + Interval::new(292, 292), + Interval::new(294, 294), + Interval::new(296, 296), + Interval::new(298, 298), + Interval::new(300, 300), + Interval::new(302, 302), + Interval::new(304, 304), + Interval::new(306, 306), + Interval::new(308, 308), + Interval::new(310, 310), + Interval::new(313, 313), + Interval::new(315, 315), + Interval::new(317, 317), + Interval::new(319, 319), + Interval::new(321, 321), + Interval::new(323, 323), + Interval::new(325, 325), + Interval::new(327, 327), + Interval::new(330, 330), + Interval::new(332, 332), + Interval::new(334, 334), + Interval::new(336, 336), + Interval::new(338, 338), + Interval::new(340, 340), + Interval::new(342, 342), + Interval::new(344, 344), + Interval::new(346, 346), + Interval::new(348, 348), + Interval::new(350, 350), + Interval::new(352, 352), + Interval::new(354, 354), + Interval::new(356, 356), + Interval::new(358, 358), + Interval::new(360, 360), + Interval::new(362, 362), + Interval::new(364, 364), + Interval::new(366, 366), + Interval::new(368, 368), + Interval::new(370, 370), + Interval::new(372, 372), + Interval::new(374, 374), + Interval::new(376, 377), + Interval::new(379, 379), + Interval::new(381, 381), + Interval::new(385, 386), + Interval::new(388, 388), + Interval::new(390, 391), + Interval::new(393, 395), + Interval::new(398, 401), + Interval::new(403, 404), + Interval::new(406, 408), + Interval::new(412, 413), + Interval::new(415, 416), + Interval::new(418, 418), + Interval::new(420, 420), + Interval::new(422, 423), + Interval::new(425, 425), + Interval::new(428, 428), + Interval::new(430, 431), + Interval::new(433, 435), + Interval::new(437, 437), + Interval::new(439, 440), + Interval::new(444, 444), + Interval::new(452, 453), + Interval::new(455, 456), + Interval::new(458, 459), + Interval::new(461, 461), + Interval::new(463, 463), + Interval::new(465, 465), + Interval::new(467, 467), + Interval::new(469, 469), + Interval::new(471, 471), + Interval::new(473, 473), + Interval::new(475, 475), + Interval::new(478, 478), + Interval::new(480, 480), + Interval::new(482, 482), + Interval::new(484, 484), + Interval::new(486, 486), + Interval::new(488, 488), + Interval::new(490, 490), + Interval::new(492, 492), + Interval::new(494, 494), + Interval::new(497, 498), + Interval::new(500, 500), + Interval::new(502, 504), + Interval::new(506, 506), + Interval::new(508, 508), + Interval::new(510, 510), + Interval::new(512, 512), + Interval::new(514, 514), + Interval::new(516, 516), + Interval::new(518, 518), + Interval::new(520, 520), + Interval::new(522, 522), + Interval::new(524, 524), + Interval::new(526, 526), + Interval::new(528, 528), + Interval::new(530, 530), + Interval::new(532, 532), + Interval::new(534, 534), + Interval::new(536, 536), + Interval::new(538, 538), + Interval::new(540, 540), + Interval::new(542, 542), + Interval::new(544, 544), + Interval::new(546, 546), + Interval::new(548, 548), + Interval::new(550, 550), + Interval::new(552, 552), + Interval::new(554, 554), + Interval::new(556, 556), + Interval::new(558, 558), + Interval::new(560, 560), + Interval::new(562, 562), + Interval::new(570, 571), + Interval::new(573, 574), + Interval::new(577, 577), + Interval::new(579, 582), + Interval::new(584, 584), + Interval::new(586, 586), + Interval::new(588, 588), + Interval::new(590, 590), + Interval::new(880, 880), + Interval::new(882, 882), + Interval::new(886, 886), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 911), + Interval::new(913, 929), + Interval::new(931, 939), + Interval::new(975, 975), + Interval::new(984, 984), + Interval::new(986, 986), + Interval::new(988, 988), + Interval::new(990, 990), + Interval::new(992, 992), + Interval::new(994, 994), + Interval::new(996, 996), + Interval::new(998, 998), + Interval::new(1000, 1000), + Interval::new(1002, 1002), + Interval::new(1004, 1004), + Interval::new(1006, 1006), + Interval::new(1012, 1012), + Interval::new(1015, 1015), + Interval::new(1017, 1018), + Interval::new(1021, 1071), + Interval::new(1120, 1120), + Interval::new(1122, 1122), + Interval::new(1124, 1124), + Interval::new(1126, 1126), + Interval::new(1128, 1128), + Interval::new(1130, 1130), + Interval::new(1132, 1132), + Interval::new(1134, 1134), + Interval::new(1136, 1136), + Interval::new(1138, 1138), + Interval::new(1140, 1140), + Interval::new(1142, 1142), + Interval::new(1144, 1144), + Interval::new(1146, 1146), + Interval::new(1148, 1148), + Interval::new(1150, 1150), + Interval::new(1152, 1152), + Interval::new(1162, 1162), + Interval::new(1164, 1164), + Interval::new(1166, 1166), + Interval::new(1168, 1168), + Interval::new(1170, 1170), + Interval::new(1172, 1172), + Interval::new(1174, 1174), + Interval::new(1176, 1176), + Interval::new(1178, 1178), + Interval::new(1180, 1180), + Interval::new(1182, 1182), + Interval::new(1184, 1184), + Interval::new(1186, 1186), + Interval::new(1188, 1188), + Interval::new(1190, 1190), + Interval::new(1192, 1192), + Interval::new(1194, 1194), + Interval::new(1196, 1196), + Interval::new(1198, 1198), + Interval::new(1200, 1200), + Interval::new(1202, 1202), + Interval::new(1204, 1204), + Interval::new(1206, 1206), + Interval::new(1208, 1208), + Interval::new(1210, 1210), + Interval::new(1212, 1212), + Interval::new(1214, 1214), + Interval::new(1216, 1217), + Interval::new(1219, 1219), + Interval::new(1221, 1221), + Interval::new(1223, 1223), + Interval::new(1225, 1225), + Interval::new(1227, 1227), + Interval::new(1229, 1229), + Interval::new(1232, 1232), + Interval::new(1234, 1234), + Interval::new(1236, 1236), + Interval::new(1238, 1238), + Interval::new(1240, 1240), + Interval::new(1242, 1242), + Interval::new(1244, 1244), + Interval::new(1246, 1246), + Interval::new(1248, 1248), + Interval::new(1250, 1250), + Interval::new(1252, 1252), + Interval::new(1254, 1254), + Interval::new(1256, 1256), + Interval::new(1258, 1258), + Interval::new(1260, 1260), + Interval::new(1262, 1262), + Interval::new(1264, 1264), + Interval::new(1266, 1266), + Interval::new(1268, 1268), + Interval::new(1270, 1270), + Interval::new(1272, 1272), + Interval::new(1274, 1274), + Interval::new(1276, 1276), + Interval::new(1278, 1278), + Interval::new(1280, 1280), + Interval::new(1282, 1282), + Interval::new(1284, 1284), + Interval::new(1286, 1286), + Interval::new(1288, 1288), + Interval::new(1290, 1290), + Interval::new(1292, 1292), + Interval::new(1294, 1294), + Interval::new(1296, 1296), + Interval::new(1298, 1298), + Interval::new(1300, 1300), + Interval::new(1302, 1302), + Interval::new(1304, 1304), + Interval::new(1306, 1306), + Interval::new(1308, 1308), + Interval::new(1310, 1310), + Interval::new(1312, 1312), + Interval::new(1314, 1314), + Interval::new(1316, 1316), + Interval::new(1318, 1318), + Interval::new(1320, 1320), + Interval::new(1322, 1322), + Interval::new(1324, 1324), + Interval::new(1326, 1326), + Interval::new(1329, 1366), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(5024, 5109), + Interval::new(7305, 7305), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7680, 7680), + Interval::new(7682, 7682), + Interval::new(7684, 7684), + Interval::new(7686, 7686), + Interval::new(7688, 7688), + Interval::new(7690, 7690), + Interval::new(7692, 7692), + Interval::new(7694, 7694), + Interval::new(7696, 7696), + Interval::new(7698, 7698), + Interval::new(7700, 7700), + Interval::new(7702, 7702), + Interval::new(7704, 7704), + Interval::new(7706, 7706), + Interval::new(7708, 7708), + Interval::new(7710, 7710), + Interval::new(7712, 7712), + Interval::new(7714, 7714), + Interval::new(7716, 7716), + Interval::new(7718, 7718), + Interval::new(7720, 7720), + Interval::new(7722, 7722), + Interval::new(7724, 7724), + Interval::new(7726, 7726), + Interval::new(7728, 7728), + Interval::new(7730, 7730), + Interval::new(7732, 7732), + Interval::new(7734, 7734), + Interval::new(7736, 7736), + Interval::new(7738, 7738), + Interval::new(7740, 7740), + Interval::new(7742, 7742), + Interval::new(7744, 7744), + Interval::new(7746, 7746), + Interval::new(7748, 7748), + Interval::new(7750, 7750), + Interval::new(7752, 7752), + Interval::new(7754, 7754), + Interval::new(7756, 7756), + Interval::new(7758, 7758), + Interval::new(7760, 7760), + Interval::new(7762, 7762), + Interval::new(7764, 7764), + Interval::new(7766, 7766), + Interval::new(7768, 7768), + Interval::new(7770, 7770), + Interval::new(7772, 7772), + Interval::new(7774, 7774), + Interval::new(7776, 7776), + Interval::new(7778, 7778), + Interval::new(7780, 7780), + Interval::new(7782, 7782), + Interval::new(7784, 7784), + Interval::new(7786, 7786), + Interval::new(7788, 7788), + Interval::new(7790, 7790), + Interval::new(7792, 7792), + Interval::new(7794, 7794), + Interval::new(7796, 7796), + Interval::new(7798, 7798), + Interval::new(7800, 7800), + Interval::new(7802, 7802), + Interval::new(7804, 7804), + Interval::new(7806, 7806), + Interval::new(7808, 7808), + Interval::new(7810, 7810), + Interval::new(7812, 7812), + Interval::new(7814, 7814), + Interval::new(7816, 7816), + Interval::new(7818, 7818), + Interval::new(7820, 7820), + Interval::new(7822, 7822), + Interval::new(7824, 7824), + Interval::new(7826, 7826), + Interval::new(7828, 7828), + Interval::new(7838, 7838), + Interval::new(7840, 7840), + Interval::new(7842, 7842), + Interval::new(7844, 7844), + Interval::new(7846, 7846), + Interval::new(7848, 7848), + Interval::new(7850, 7850), + Interval::new(7852, 7852), + Interval::new(7854, 7854), + Interval::new(7856, 7856), + Interval::new(7858, 7858), + Interval::new(7860, 7860), + Interval::new(7862, 7862), + Interval::new(7864, 7864), + Interval::new(7866, 7866), + Interval::new(7868, 7868), + Interval::new(7870, 7870), + Interval::new(7872, 7872), + Interval::new(7874, 7874), + Interval::new(7876, 7876), + Interval::new(7878, 7878), + Interval::new(7880, 7880), + Interval::new(7882, 7882), + Interval::new(7884, 7884), + Interval::new(7886, 7886), + Interval::new(7888, 7888), + Interval::new(7890, 7890), + Interval::new(7892, 7892), + Interval::new(7894, 7894), + Interval::new(7896, 7896), + Interval::new(7898, 7898), + Interval::new(7900, 7900), + Interval::new(7902, 7902), + Interval::new(7904, 7904), + Interval::new(7906, 7906), + Interval::new(7908, 7908), + Interval::new(7910, 7910), + Interval::new(7912, 7912), + Interval::new(7914, 7914), + Interval::new(7916, 7916), + Interval::new(7918, 7918), + Interval::new(7920, 7920), + Interval::new(7922, 7922), + Interval::new(7924, 7924), + Interval::new(7926, 7926), + Interval::new(7928, 7928), + Interval::new(7930, 7930), + Interval::new(7932, 7932), + Interval::new(7934, 7934), + Interval::new(7944, 7951), + Interval::new(7960, 7965), + Interval::new(7976, 7983), + Interval::new(7992, 7999), + Interval::new(8008, 8013), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8031), + Interval::new(8040, 8047), + Interval::new(8072, 8079), + Interval::new(8088, 8095), + Interval::new(8104, 8111), + Interval::new(8120, 8124), + Interval::new(8136, 8140), + Interval::new(8152, 8155), + Interval::new(8168, 8172), + Interval::new(8184, 8188), + Interval::new(8486, 8486), + Interval::new(8490, 8491), + Interval::new(8498, 8498), + Interval::new(8544, 8559), + Interval::new(8579, 8579), + Interval::new(9398, 9423), + Interval::new(11264, 11311), + Interval::new(11360, 11360), + Interval::new(11362, 11364), + Interval::new(11367, 11367), + Interval::new(11369, 11369), + Interval::new(11371, 11371), + Interval::new(11373, 11376), + Interval::new(11378, 11378), + Interval::new(11381, 11381), + Interval::new(11390, 11392), + Interval::new(11394, 11394), + Interval::new(11396, 11396), + Interval::new(11398, 11398), + Interval::new(11400, 11400), + Interval::new(11402, 11402), + Interval::new(11404, 11404), + Interval::new(11406, 11406), + Interval::new(11408, 11408), + Interval::new(11410, 11410), + Interval::new(11412, 11412), + Interval::new(11414, 11414), + Interval::new(11416, 11416), + Interval::new(11418, 11418), + Interval::new(11420, 11420), + Interval::new(11422, 11422), + Interval::new(11424, 11424), + Interval::new(11426, 11426), + Interval::new(11428, 11428), + Interval::new(11430, 11430), + Interval::new(11432, 11432), + Interval::new(11434, 11434), + Interval::new(11436, 11436), + Interval::new(11438, 11438), + Interval::new(11440, 11440), + Interval::new(11442, 11442), + Interval::new(11444, 11444), + Interval::new(11446, 11446), + Interval::new(11448, 11448), + Interval::new(11450, 11450), + Interval::new(11452, 11452), + Interval::new(11454, 11454), + Interval::new(11456, 11456), + Interval::new(11458, 11458), + Interval::new(11460, 11460), + Interval::new(11462, 11462), + Interval::new(11464, 11464), + Interval::new(11466, 11466), + Interval::new(11468, 11468), + Interval::new(11470, 11470), + Interval::new(11472, 11472), + Interval::new(11474, 11474), + Interval::new(11476, 11476), + Interval::new(11478, 11478), + Interval::new(11480, 11480), + Interval::new(11482, 11482), + Interval::new(11484, 11484), + Interval::new(11486, 11486), + Interval::new(11488, 11488), + Interval::new(11490, 11490), + Interval::new(11499, 11499), + Interval::new(11501, 11501), + Interval::new(11506, 11506), + Interval::new(42560, 42560), + Interval::new(42562, 42562), + Interval::new(42564, 42564), + Interval::new(42566, 42566), + Interval::new(42568, 42568), + Interval::new(42570, 42570), + Interval::new(42572, 42572), + Interval::new(42574, 42574), + Interval::new(42576, 42576), + Interval::new(42578, 42578), + Interval::new(42580, 42580), + Interval::new(42582, 42582), + Interval::new(42584, 42584), + Interval::new(42586, 42586), + Interval::new(42588, 42588), + Interval::new(42590, 42590), + Interval::new(42592, 42592), + Interval::new(42594, 42594), + Interval::new(42596, 42596), + Interval::new(42598, 42598), + Interval::new(42600, 42600), + Interval::new(42602, 42602), + Interval::new(42604, 42604), + Interval::new(42624, 42624), + Interval::new(42626, 42626), + Interval::new(42628, 42628), + Interval::new(42630, 42630), + Interval::new(42632, 42632), + Interval::new(42634, 42634), + Interval::new(42636, 42636), + Interval::new(42638, 42638), + Interval::new(42640, 42640), + Interval::new(42642, 42642), + Interval::new(42644, 42644), + Interval::new(42646, 42646), + Interval::new(42648, 42648), + Interval::new(42650, 42650), + Interval::new(42786, 42786), + Interval::new(42788, 42788), + Interval::new(42790, 42790), + Interval::new(42792, 42792), + Interval::new(42794, 42794), + Interval::new(42796, 42796), + Interval::new(42798, 42798), + Interval::new(42802, 42802), + Interval::new(42804, 42804), + Interval::new(42806, 42806), + Interval::new(42808, 42808), + Interval::new(42810, 42810), + Interval::new(42812, 42812), + Interval::new(42814, 42814), + Interval::new(42816, 42816), + Interval::new(42818, 42818), + Interval::new(42820, 42820), + Interval::new(42822, 42822), + Interval::new(42824, 42824), + Interval::new(42826, 42826), + Interval::new(42828, 42828), + Interval::new(42830, 42830), + Interval::new(42832, 42832), + Interval::new(42834, 42834), + Interval::new(42836, 42836), + Interval::new(42838, 42838), + Interval::new(42840, 42840), + Interval::new(42842, 42842), + Interval::new(42844, 42844), + Interval::new(42846, 42846), + Interval::new(42848, 42848), + Interval::new(42850, 42850), + Interval::new(42852, 42852), + Interval::new(42854, 42854), + Interval::new(42856, 42856), + Interval::new(42858, 42858), + Interval::new(42860, 42860), + Interval::new(42862, 42862), + Interval::new(42873, 42873), + Interval::new(42875, 42875), + Interval::new(42877, 42878), + Interval::new(42880, 42880), + Interval::new(42882, 42882), + Interval::new(42884, 42884), + Interval::new(42886, 42886), + Interval::new(42891, 42891), + Interval::new(42893, 42893), + Interval::new(42896, 42896), + Interval::new(42898, 42898), + Interval::new(42902, 42902), + Interval::new(42904, 42904), + Interval::new(42906, 42906), + Interval::new(42908, 42908), + Interval::new(42910, 42910), + Interval::new(42912, 42912), + Interval::new(42914, 42914), + Interval::new(42916, 42916), + Interval::new(42918, 42918), + Interval::new(42920, 42920), + Interval::new(42922, 42926), + Interval::new(42928, 42932), + Interval::new(42934, 42934), + Interval::new(42936, 42936), + Interval::new(42938, 42938), + Interval::new(42940, 42940), + Interval::new(42942, 42942), + Interval::new(42944, 42944), + Interval::new(42946, 42946), + Interval::new(42948, 42951), + Interval::new(42953, 42953), + Interval::new(42955, 42956), + Interval::new(42958, 42958), + Interval::new(42960, 42960), + Interval::new(42962, 42962), + Interval::new(42964, 42964), + Interval::new(42966, 42966), + Interval::new(42968, 42968), + Interval::new(42970, 42970), + Interval::new(42972, 42972), + Interval::new(42997, 42997), + Interval::new(65313, 65338), + Interval::new(66560, 66599), + Interval::new(66736, 66771), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(68736, 68786), + Interval::new(68944, 68965), + Interval::new(71840, 71871), + Interval::new(93760, 93791), + Interval::new(93856, 93880), + Interval::new(125184, 125217), +]; + +/// Return the code point ranges of the 'Changes_When_Lowercased' Unicode property. +pub(crate) fn changes_when_lowercased_ranges() -> &'static [Interval] { + &CHANGES_WHEN_LOWERCASED +} + +const CHANGES_WHEN_TITLECASED: [Interval; 633] = [ + Interval::new(97, 122), + Interval::new(181, 181), + Interval::new(223, 246), + Interval::new(248, 255), + Interval::new(257, 257), + Interval::new(259, 259), + Interval::new(261, 261), + Interval::new(263, 263), + Interval::new(265, 265), + Interval::new(267, 267), + Interval::new(269, 269), + Interval::new(271, 271), + Interval::new(273, 273), + Interval::new(275, 275), + Interval::new(277, 277), + Interval::new(279, 279), + Interval::new(281, 281), + Interval::new(283, 283), + Interval::new(285, 285), + Interval::new(287, 287), + Interval::new(289, 289), + Interval::new(291, 291), + Interval::new(293, 293), + Interval::new(295, 295), + Interval::new(297, 297), + Interval::new(299, 299), + Interval::new(301, 301), + Interval::new(303, 303), + Interval::new(305, 305), + Interval::new(307, 307), + Interval::new(309, 309), + Interval::new(311, 311), + Interval::new(314, 314), + Interval::new(316, 316), + Interval::new(318, 318), + Interval::new(320, 320), + Interval::new(322, 322), + Interval::new(324, 324), + Interval::new(326, 326), + Interval::new(328, 329), + Interval::new(331, 331), + Interval::new(333, 333), + Interval::new(335, 335), + Interval::new(337, 337), + Interval::new(339, 339), + Interval::new(341, 341), + Interval::new(343, 343), + Interval::new(345, 345), + Interval::new(347, 347), + Interval::new(349, 349), + Interval::new(351, 351), + Interval::new(353, 353), + Interval::new(355, 355), + Interval::new(357, 357), + Interval::new(359, 359), + Interval::new(361, 361), + Interval::new(363, 363), + Interval::new(365, 365), + Interval::new(367, 367), + Interval::new(369, 369), + Interval::new(371, 371), + Interval::new(373, 373), + Interval::new(375, 375), + Interval::new(378, 378), + Interval::new(380, 380), + Interval::new(382, 384), + Interval::new(387, 387), + Interval::new(389, 389), + Interval::new(392, 392), + Interval::new(396, 396), + Interval::new(402, 402), + Interval::new(405, 405), + Interval::new(409, 411), + Interval::new(414, 414), + Interval::new(417, 417), + Interval::new(419, 419), + Interval::new(421, 421), + Interval::new(424, 424), + Interval::new(429, 429), + Interval::new(432, 432), + Interval::new(436, 436), + Interval::new(438, 438), + Interval::new(441, 441), + Interval::new(445, 445), + Interval::new(447, 447), + Interval::new(452, 452), + Interval::new(454, 455), + Interval::new(457, 458), + Interval::new(460, 460), + Interval::new(462, 462), + Interval::new(464, 464), + Interval::new(466, 466), + Interval::new(468, 468), + Interval::new(470, 470), + Interval::new(472, 472), + Interval::new(474, 474), + Interval::new(476, 477), + Interval::new(479, 479), + Interval::new(481, 481), + Interval::new(483, 483), + Interval::new(485, 485), + Interval::new(487, 487), + Interval::new(489, 489), + Interval::new(491, 491), + Interval::new(493, 493), + Interval::new(495, 497), + Interval::new(499, 499), + Interval::new(501, 501), + Interval::new(505, 505), + Interval::new(507, 507), + Interval::new(509, 509), + Interval::new(511, 511), + Interval::new(513, 513), + Interval::new(515, 515), + Interval::new(517, 517), + Interval::new(519, 519), + Interval::new(521, 521), + Interval::new(523, 523), + Interval::new(525, 525), + Interval::new(527, 527), + Interval::new(529, 529), + Interval::new(531, 531), + Interval::new(533, 533), + Interval::new(535, 535), + Interval::new(537, 537), + Interval::new(539, 539), + Interval::new(541, 541), + Interval::new(543, 543), + Interval::new(547, 547), + Interval::new(549, 549), + Interval::new(551, 551), + Interval::new(553, 553), + Interval::new(555, 555), + Interval::new(557, 557), + Interval::new(559, 559), + Interval::new(561, 561), + Interval::new(563, 563), + Interval::new(572, 572), + Interval::new(575, 576), + Interval::new(578, 578), + Interval::new(583, 583), + Interval::new(585, 585), + Interval::new(587, 587), + Interval::new(589, 589), + Interval::new(591, 596), + Interval::new(598, 599), + Interval::new(601, 601), + Interval::new(603, 604), + Interval::new(608, 609), + Interval::new(611, 614), + Interval::new(616, 620), + Interval::new(623, 623), + Interval::new(625, 626), + Interval::new(629, 629), + Interval::new(637, 637), + Interval::new(640, 640), + Interval::new(642, 643), + Interval::new(647, 652), + Interval::new(658, 658), + Interval::new(669, 670), + Interval::new(837, 837), + Interval::new(881, 881), + Interval::new(883, 883), + Interval::new(887, 887), + Interval::new(891, 893), + Interval::new(912, 912), + Interval::new(940, 974), + Interval::new(976, 977), + Interval::new(981, 983), + Interval::new(985, 985), + Interval::new(987, 987), + Interval::new(989, 989), + Interval::new(991, 991), + Interval::new(993, 993), + Interval::new(995, 995), + Interval::new(997, 997), + Interval::new(999, 999), + Interval::new(1001, 1001), + Interval::new(1003, 1003), + Interval::new(1005, 1005), + Interval::new(1007, 1011), + Interval::new(1013, 1013), + Interval::new(1016, 1016), + Interval::new(1019, 1019), + Interval::new(1072, 1119), + Interval::new(1121, 1121), + Interval::new(1123, 1123), + Interval::new(1125, 1125), + Interval::new(1127, 1127), + Interval::new(1129, 1129), + Interval::new(1131, 1131), + Interval::new(1133, 1133), + Interval::new(1135, 1135), + Interval::new(1137, 1137), + Interval::new(1139, 1139), + Interval::new(1141, 1141), + Interval::new(1143, 1143), + Interval::new(1145, 1145), + Interval::new(1147, 1147), + Interval::new(1149, 1149), + Interval::new(1151, 1151), + Interval::new(1153, 1153), + Interval::new(1163, 1163), + Interval::new(1165, 1165), + Interval::new(1167, 1167), + Interval::new(1169, 1169), + Interval::new(1171, 1171), + Interval::new(1173, 1173), + Interval::new(1175, 1175), + Interval::new(1177, 1177), + Interval::new(1179, 1179), + Interval::new(1181, 1181), + Interval::new(1183, 1183), + Interval::new(1185, 1185), + Interval::new(1187, 1187), + Interval::new(1189, 1189), + Interval::new(1191, 1191), + Interval::new(1193, 1193), + Interval::new(1195, 1195), + Interval::new(1197, 1197), + Interval::new(1199, 1199), + Interval::new(1201, 1201), + Interval::new(1203, 1203), + Interval::new(1205, 1205), + Interval::new(1207, 1207), + Interval::new(1209, 1209), + Interval::new(1211, 1211), + Interval::new(1213, 1213), + Interval::new(1215, 1215), + Interval::new(1218, 1218), + Interval::new(1220, 1220), + Interval::new(1222, 1222), + Interval::new(1224, 1224), + Interval::new(1226, 1226), + Interval::new(1228, 1228), + Interval::new(1230, 1231), + Interval::new(1233, 1233), + Interval::new(1235, 1235), + Interval::new(1237, 1237), + Interval::new(1239, 1239), + Interval::new(1241, 1241), + Interval::new(1243, 1243), + Interval::new(1245, 1245), + Interval::new(1247, 1247), + Interval::new(1249, 1249), + Interval::new(1251, 1251), + Interval::new(1253, 1253), + Interval::new(1255, 1255), + Interval::new(1257, 1257), + Interval::new(1259, 1259), + Interval::new(1261, 1261), + Interval::new(1263, 1263), + Interval::new(1265, 1265), + Interval::new(1267, 1267), + Interval::new(1269, 1269), + Interval::new(1271, 1271), + Interval::new(1273, 1273), + Interval::new(1275, 1275), + Interval::new(1277, 1277), + Interval::new(1279, 1279), + Interval::new(1281, 1281), + Interval::new(1283, 1283), + Interval::new(1285, 1285), + Interval::new(1287, 1287), + Interval::new(1289, 1289), + Interval::new(1291, 1291), + Interval::new(1293, 1293), + Interval::new(1295, 1295), + Interval::new(1297, 1297), + Interval::new(1299, 1299), + Interval::new(1301, 1301), + Interval::new(1303, 1303), + Interval::new(1305, 1305), + Interval::new(1307, 1307), + Interval::new(1309, 1309), + Interval::new(1311, 1311), + Interval::new(1313, 1313), + Interval::new(1315, 1315), + Interval::new(1317, 1317), + Interval::new(1319, 1319), + Interval::new(1321, 1321), + Interval::new(1323, 1323), + Interval::new(1325, 1325), + Interval::new(1327, 1327), + Interval::new(1377, 1415), + Interval::new(5112, 5117), + Interval::new(7296, 7304), + Interval::new(7306, 7306), + Interval::new(7545, 7545), + Interval::new(7549, 7549), + Interval::new(7566, 7566), + Interval::new(7681, 7681), + Interval::new(7683, 7683), + Interval::new(7685, 7685), + Interval::new(7687, 7687), + Interval::new(7689, 7689), + Interval::new(7691, 7691), + Interval::new(7693, 7693), + Interval::new(7695, 7695), + Interval::new(7697, 7697), + Interval::new(7699, 7699), + Interval::new(7701, 7701), + Interval::new(7703, 7703), + Interval::new(7705, 7705), + Interval::new(7707, 7707), + Interval::new(7709, 7709), + Interval::new(7711, 7711), + Interval::new(7713, 7713), + Interval::new(7715, 7715), + Interval::new(7717, 7717), + Interval::new(7719, 7719), + Interval::new(7721, 7721), + Interval::new(7723, 7723), + Interval::new(7725, 7725), + Interval::new(7727, 7727), + Interval::new(7729, 7729), + Interval::new(7731, 7731), + Interval::new(7733, 7733), + Interval::new(7735, 7735), + Interval::new(7737, 7737), + Interval::new(7739, 7739), + Interval::new(7741, 7741), + Interval::new(7743, 7743), + Interval::new(7745, 7745), + Interval::new(7747, 7747), + Interval::new(7749, 7749), + Interval::new(7751, 7751), + Interval::new(7753, 7753), + Interval::new(7755, 7755), + Interval::new(7757, 7757), + Interval::new(7759, 7759), + Interval::new(7761, 7761), + Interval::new(7763, 7763), + Interval::new(7765, 7765), + Interval::new(7767, 7767), + Interval::new(7769, 7769), + Interval::new(7771, 7771), + Interval::new(7773, 7773), + Interval::new(7775, 7775), + Interval::new(7777, 7777), + Interval::new(7779, 7779), + Interval::new(7781, 7781), + Interval::new(7783, 7783), + Interval::new(7785, 7785), + Interval::new(7787, 7787), + Interval::new(7789, 7789), + Interval::new(7791, 7791), + Interval::new(7793, 7793), + Interval::new(7795, 7795), + Interval::new(7797, 7797), + Interval::new(7799, 7799), + Interval::new(7801, 7801), + Interval::new(7803, 7803), + Interval::new(7805, 7805), + Interval::new(7807, 7807), + Interval::new(7809, 7809), + Interval::new(7811, 7811), + Interval::new(7813, 7813), + Interval::new(7815, 7815), + Interval::new(7817, 7817), + Interval::new(7819, 7819), + Interval::new(7821, 7821), + Interval::new(7823, 7823), + Interval::new(7825, 7825), + Interval::new(7827, 7827), + Interval::new(7829, 7835), + Interval::new(7841, 7841), + Interval::new(7843, 7843), + Interval::new(7845, 7845), + Interval::new(7847, 7847), + Interval::new(7849, 7849), + Interval::new(7851, 7851), + Interval::new(7853, 7853), + Interval::new(7855, 7855), + Interval::new(7857, 7857), + Interval::new(7859, 7859), + Interval::new(7861, 7861), + Interval::new(7863, 7863), + Interval::new(7865, 7865), + Interval::new(7867, 7867), + Interval::new(7869, 7869), + Interval::new(7871, 7871), + Interval::new(7873, 7873), + Interval::new(7875, 7875), + Interval::new(7877, 7877), + Interval::new(7879, 7879), + Interval::new(7881, 7881), + Interval::new(7883, 7883), + Interval::new(7885, 7885), + Interval::new(7887, 7887), + Interval::new(7889, 7889), + Interval::new(7891, 7891), + Interval::new(7893, 7893), + Interval::new(7895, 7895), + Interval::new(7897, 7897), + Interval::new(7899, 7899), + Interval::new(7901, 7901), + Interval::new(7903, 7903), + Interval::new(7905, 7905), + Interval::new(7907, 7907), + Interval::new(7909, 7909), + Interval::new(7911, 7911), + Interval::new(7913, 7913), + Interval::new(7915, 7915), + Interval::new(7917, 7917), + Interval::new(7919, 7919), + Interval::new(7921, 7921), + Interval::new(7923, 7923), + Interval::new(7925, 7925), + Interval::new(7927, 7927), + Interval::new(7929, 7929), + Interval::new(7931, 7931), + Interval::new(7933, 7933), + Interval::new(7935, 7943), + Interval::new(7952, 7957), + Interval::new(7968, 7975), + Interval::new(7984, 7991), + Interval::new(8000, 8005), + Interval::new(8016, 8023), + Interval::new(8032, 8039), + Interval::new(8048, 8061), + Interval::new(8064, 8071), + Interval::new(8080, 8087), + Interval::new(8096, 8103), + Interval::new(8112, 8116), + Interval::new(8118, 8119), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8135), + Interval::new(8144, 8147), + Interval::new(8150, 8151), + Interval::new(8160, 8167), + Interval::new(8178, 8180), + Interval::new(8182, 8183), + Interval::new(8526, 8526), + Interval::new(8560, 8575), + Interval::new(8580, 8580), + Interval::new(9424, 9449), + Interval::new(11312, 11359), + Interval::new(11361, 11361), + Interval::new(11365, 11366), + Interval::new(11368, 11368), + Interval::new(11370, 11370), + Interval::new(11372, 11372), + Interval::new(11379, 11379), + Interval::new(11382, 11382), + Interval::new(11393, 11393), + Interval::new(11395, 11395), + Interval::new(11397, 11397), + Interval::new(11399, 11399), + Interval::new(11401, 11401), + Interval::new(11403, 11403), + Interval::new(11405, 11405), + Interval::new(11407, 11407), + Interval::new(11409, 11409), + Interval::new(11411, 11411), + Interval::new(11413, 11413), + Interval::new(11415, 11415), + Interval::new(11417, 11417), + Interval::new(11419, 11419), + Interval::new(11421, 11421), + Interval::new(11423, 11423), + Interval::new(11425, 11425), + Interval::new(11427, 11427), + Interval::new(11429, 11429), + Interval::new(11431, 11431), + Interval::new(11433, 11433), + Interval::new(11435, 11435), + Interval::new(11437, 11437), + Interval::new(11439, 11439), + Interval::new(11441, 11441), + Interval::new(11443, 11443), + Interval::new(11445, 11445), + Interval::new(11447, 11447), + Interval::new(11449, 11449), + Interval::new(11451, 11451), + Interval::new(11453, 11453), + Interval::new(11455, 11455), + Interval::new(11457, 11457), + Interval::new(11459, 11459), + Interval::new(11461, 11461), + Interval::new(11463, 11463), + Interval::new(11465, 11465), + Interval::new(11467, 11467), + Interval::new(11469, 11469), + Interval::new(11471, 11471), + Interval::new(11473, 11473), + Interval::new(11475, 11475), + Interval::new(11477, 11477), + Interval::new(11479, 11479), + Interval::new(11481, 11481), + Interval::new(11483, 11483), + Interval::new(11485, 11485), + Interval::new(11487, 11487), + Interval::new(11489, 11489), + Interval::new(11491, 11491), + Interval::new(11500, 11500), + Interval::new(11502, 11502), + Interval::new(11507, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42561, 42561), + Interval::new(42563, 42563), + Interval::new(42565, 42565), + Interval::new(42567, 42567), + Interval::new(42569, 42569), + Interval::new(42571, 42571), + Interval::new(42573, 42573), + Interval::new(42575, 42575), + Interval::new(42577, 42577), + Interval::new(42579, 42579), + Interval::new(42581, 42581), + Interval::new(42583, 42583), + Interval::new(42585, 42585), + Interval::new(42587, 42587), + Interval::new(42589, 42589), + Interval::new(42591, 42591), + Interval::new(42593, 42593), + Interval::new(42595, 42595), + Interval::new(42597, 42597), + Interval::new(42599, 42599), + Interval::new(42601, 42601), + Interval::new(42603, 42603), + Interval::new(42605, 42605), + Interval::new(42625, 42625), + Interval::new(42627, 42627), + Interval::new(42629, 42629), + Interval::new(42631, 42631), + Interval::new(42633, 42633), + Interval::new(42635, 42635), + Interval::new(42637, 42637), + Interval::new(42639, 42639), + Interval::new(42641, 42641), + Interval::new(42643, 42643), + Interval::new(42645, 42645), + Interval::new(42647, 42647), + Interval::new(42649, 42649), + Interval::new(42651, 42651), + Interval::new(42787, 42787), + Interval::new(42789, 42789), + Interval::new(42791, 42791), + Interval::new(42793, 42793), + Interval::new(42795, 42795), + Interval::new(42797, 42797), + Interval::new(42799, 42799), + Interval::new(42803, 42803), + Interval::new(42805, 42805), + Interval::new(42807, 42807), + Interval::new(42809, 42809), + Interval::new(42811, 42811), + Interval::new(42813, 42813), + Interval::new(42815, 42815), + Interval::new(42817, 42817), + Interval::new(42819, 42819), + Interval::new(42821, 42821), + Interval::new(42823, 42823), + Interval::new(42825, 42825), + Interval::new(42827, 42827), + Interval::new(42829, 42829), + Interval::new(42831, 42831), + Interval::new(42833, 42833), + Interval::new(42835, 42835), + Interval::new(42837, 42837), + Interval::new(42839, 42839), + Interval::new(42841, 42841), + Interval::new(42843, 42843), + Interval::new(42845, 42845), + Interval::new(42847, 42847), + Interval::new(42849, 42849), + Interval::new(42851, 42851), + Interval::new(42853, 42853), + Interval::new(42855, 42855), + Interval::new(42857, 42857), + Interval::new(42859, 42859), + Interval::new(42861, 42861), + Interval::new(42863, 42863), + Interval::new(42874, 42874), + Interval::new(42876, 42876), + Interval::new(42879, 42879), + Interval::new(42881, 42881), + Interval::new(42883, 42883), + Interval::new(42885, 42885), + Interval::new(42887, 42887), + Interval::new(42892, 42892), + Interval::new(42897, 42897), + Interval::new(42899, 42900), + Interval::new(42903, 42903), + Interval::new(42905, 42905), + Interval::new(42907, 42907), + Interval::new(42909, 42909), + Interval::new(42911, 42911), + Interval::new(42913, 42913), + Interval::new(42915, 42915), + Interval::new(42917, 42917), + Interval::new(42919, 42919), + Interval::new(42921, 42921), + Interval::new(42933, 42933), + Interval::new(42935, 42935), + Interval::new(42937, 42937), + Interval::new(42939, 42939), + Interval::new(42941, 42941), + Interval::new(42943, 42943), + Interval::new(42945, 42945), + Interval::new(42947, 42947), + Interval::new(42952, 42952), + Interval::new(42954, 42954), + Interval::new(42957, 42957), + Interval::new(42959, 42959), + Interval::new(42961, 42961), + Interval::new(42963, 42963), + Interval::new(42965, 42965), + Interval::new(42967, 42967), + Interval::new(42969, 42969), + Interval::new(42971, 42971), + Interval::new(42998, 42998), + Interval::new(43859, 43859), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65345, 65370), + Interval::new(66600, 66639), + Interval::new(66776, 66811), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(68800, 68850), + Interval::new(68976, 68997), + Interval::new(71872, 71903), + Interval::new(93792, 93823), + Interval::new(93883, 93907), + Interval::new(125218, 125251), +]; + +/// Return the code point ranges of the 'Changes_When_Titlecased' Unicode property. +pub(crate) fn changes_when_titlecased_ranges() -> &'static [Interval] { + &CHANGES_WHEN_TITLECASED +} + +const CHANGES_WHEN_UPPERCASED: [Interval; 634] = [ + Interval::new(97, 122), + Interval::new(181, 181), + Interval::new(223, 246), + Interval::new(248, 255), + Interval::new(257, 257), + Interval::new(259, 259), + Interval::new(261, 261), + Interval::new(263, 263), + Interval::new(265, 265), + Interval::new(267, 267), + Interval::new(269, 269), + Interval::new(271, 271), + Interval::new(273, 273), + Interval::new(275, 275), + Interval::new(277, 277), + Interval::new(279, 279), + Interval::new(281, 281), + Interval::new(283, 283), + Interval::new(285, 285), + Interval::new(287, 287), + Interval::new(289, 289), + Interval::new(291, 291), + Interval::new(293, 293), + Interval::new(295, 295), + Interval::new(297, 297), + Interval::new(299, 299), + Interval::new(301, 301), + Interval::new(303, 303), + Interval::new(305, 305), + Interval::new(307, 307), + Interval::new(309, 309), + Interval::new(311, 311), + Interval::new(314, 314), + Interval::new(316, 316), + Interval::new(318, 318), + Interval::new(320, 320), + Interval::new(322, 322), + Interval::new(324, 324), + Interval::new(326, 326), + Interval::new(328, 329), + Interval::new(331, 331), + Interval::new(333, 333), + Interval::new(335, 335), + Interval::new(337, 337), + Interval::new(339, 339), + Interval::new(341, 341), + Interval::new(343, 343), + Interval::new(345, 345), + Interval::new(347, 347), + Interval::new(349, 349), + Interval::new(351, 351), + Interval::new(353, 353), + Interval::new(355, 355), + Interval::new(357, 357), + Interval::new(359, 359), + Interval::new(361, 361), + Interval::new(363, 363), + Interval::new(365, 365), + Interval::new(367, 367), + Interval::new(369, 369), + Interval::new(371, 371), + Interval::new(373, 373), + Interval::new(375, 375), + Interval::new(378, 378), + Interval::new(380, 380), + Interval::new(382, 384), + Interval::new(387, 387), + Interval::new(389, 389), + Interval::new(392, 392), + Interval::new(396, 396), + Interval::new(402, 402), + Interval::new(405, 405), + Interval::new(409, 411), + Interval::new(414, 414), + Interval::new(417, 417), + Interval::new(419, 419), + Interval::new(421, 421), + Interval::new(424, 424), + Interval::new(429, 429), + Interval::new(432, 432), + Interval::new(436, 436), + Interval::new(438, 438), + Interval::new(441, 441), + Interval::new(445, 445), + Interval::new(447, 447), + Interval::new(453, 454), + Interval::new(456, 457), + Interval::new(459, 460), + Interval::new(462, 462), + Interval::new(464, 464), + Interval::new(466, 466), + Interval::new(468, 468), + Interval::new(470, 470), + Interval::new(472, 472), + Interval::new(474, 474), + Interval::new(476, 477), + Interval::new(479, 479), + Interval::new(481, 481), + Interval::new(483, 483), + Interval::new(485, 485), + Interval::new(487, 487), + Interval::new(489, 489), + Interval::new(491, 491), + Interval::new(493, 493), + Interval::new(495, 496), + Interval::new(498, 499), + Interval::new(501, 501), + Interval::new(505, 505), + Interval::new(507, 507), + Interval::new(509, 509), + Interval::new(511, 511), + Interval::new(513, 513), + Interval::new(515, 515), + Interval::new(517, 517), + Interval::new(519, 519), + Interval::new(521, 521), + Interval::new(523, 523), + Interval::new(525, 525), + Interval::new(527, 527), + Interval::new(529, 529), + Interval::new(531, 531), + Interval::new(533, 533), + Interval::new(535, 535), + Interval::new(537, 537), + Interval::new(539, 539), + Interval::new(541, 541), + Interval::new(543, 543), + Interval::new(547, 547), + Interval::new(549, 549), + Interval::new(551, 551), + Interval::new(553, 553), + Interval::new(555, 555), + Interval::new(557, 557), + Interval::new(559, 559), + Interval::new(561, 561), + Interval::new(563, 563), + Interval::new(572, 572), + Interval::new(575, 576), + Interval::new(578, 578), + Interval::new(583, 583), + Interval::new(585, 585), + Interval::new(587, 587), + Interval::new(589, 589), + Interval::new(591, 596), + Interval::new(598, 599), + Interval::new(601, 601), + Interval::new(603, 604), + Interval::new(608, 609), + Interval::new(611, 614), + Interval::new(616, 620), + Interval::new(623, 623), + Interval::new(625, 626), + Interval::new(629, 629), + Interval::new(637, 637), + Interval::new(640, 640), + Interval::new(642, 643), + Interval::new(647, 652), + Interval::new(658, 658), + Interval::new(669, 670), + Interval::new(837, 837), + Interval::new(881, 881), + Interval::new(883, 883), + Interval::new(887, 887), + Interval::new(891, 893), + Interval::new(912, 912), + Interval::new(940, 974), + Interval::new(976, 977), + Interval::new(981, 983), + Interval::new(985, 985), + Interval::new(987, 987), + Interval::new(989, 989), + Interval::new(991, 991), + Interval::new(993, 993), + Interval::new(995, 995), + Interval::new(997, 997), + Interval::new(999, 999), + Interval::new(1001, 1001), + Interval::new(1003, 1003), + Interval::new(1005, 1005), + Interval::new(1007, 1011), + Interval::new(1013, 1013), + Interval::new(1016, 1016), + Interval::new(1019, 1019), + Interval::new(1072, 1119), + Interval::new(1121, 1121), + Interval::new(1123, 1123), + Interval::new(1125, 1125), + Interval::new(1127, 1127), + Interval::new(1129, 1129), + Interval::new(1131, 1131), + Interval::new(1133, 1133), + Interval::new(1135, 1135), + Interval::new(1137, 1137), + Interval::new(1139, 1139), + Interval::new(1141, 1141), + Interval::new(1143, 1143), + Interval::new(1145, 1145), + Interval::new(1147, 1147), + Interval::new(1149, 1149), + Interval::new(1151, 1151), + Interval::new(1153, 1153), + Interval::new(1163, 1163), + Interval::new(1165, 1165), + Interval::new(1167, 1167), + Interval::new(1169, 1169), + Interval::new(1171, 1171), + Interval::new(1173, 1173), + Interval::new(1175, 1175), + Interval::new(1177, 1177), + Interval::new(1179, 1179), + Interval::new(1181, 1181), + Interval::new(1183, 1183), + Interval::new(1185, 1185), + Interval::new(1187, 1187), + Interval::new(1189, 1189), + Interval::new(1191, 1191), + Interval::new(1193, 1193), + Interval::new(1195, 1195), + Interval::new(1197, 1197), + Interval::new(1199, 1199), + Interval::new(1201, 1201), + Interval::new(1203, 1203), + Interval::new(1205, 1205), + Interval::new(1207, 1207), + Interval::new(1209, 1209), + Interval::new(1211, 1211), + Interval::new(1213, 1213), + Interval::new(1215, 1215), + Interval::new(1218, 1218), + Interval::new(1220, 1220), + Interval::new(1222, 1222), + Interval::new(1224, 1224), + Interval::new(1226, 1226), + Interval::new(1228, 1228), + Interval::new(1230, 1231), + Interval::new(1233, 1233), + Interval::new(1235, 1235), + Interval::new(1237, 1237), + Interval::new(1239, 1239), + Interval::new(1241, 1241), + Interval::new(1243, 1243), + Interval::new(1245, 1245), + Interval::new(1247, 1247), + Interval::new(1249, 1249), + Interval::new(1251, 1251), + Interval::new(1253, 1253), + Interval::new(1255, 1255), + Interval::new(1257, 1257), + Interval::new(1259, 1259), + Interval::new(1261, 1261), + Interval::new(1263, 1263), + Interval::new(1265, 1265), + Interval::new(1267, 1267), + Interval::new(1269, 1269), + Interval::new(1271, 1271), + Interval::new(1273, 1273), + Interval::new(1275, 1275), + Interval::new(1277, 1277), + Interval::new(1279, 1279), + Interval::new(1281, 1281), + Interval::new(1283, 1283), + Interval::new(1285, 1285), + Interval::new(1287, 1287), + Interval::new(1289, 1289), + Interval::new(1291, 1291), + Interval::new(1293, 1293), + Interval::new(1295, 1295), + Interval::new(1297, 1297), + Interval::new(1299, 1299), + Interval::new(1301, 1301), + Interval::new(1303, 1303), + Interval::new(1305, 1305), + Interval::new(1307, 1307), + Interval::new(1309, 1309), + Interval::new(1311, 1311), + Interval::new(1313, 1313), + Interval::new(1315, 1315), + Interval::new(1317, 1317), + Interval::new(1319, 1319), + Interval::new(1321, 1321), + Interval::new(1323, 1323), + Interval::new(1325, 1325), + Interval::new(1327, 1327), + Interval::new(1377, 1415), + Interval::new(4304, 4346), + Interval::new(4349, 4351), + Interval::new(5112, 5117), + Interval::new(7296, 7304), + Interval::new(7306, 7306), + Interval::new(7545, 7545), + Interval::new(7549, 7549), + Interval::new(7566, 7566), + Interval::new(7681, 7681), + Interval::new(7683, 7683), + Interval::new(7685, 7685), + Interval::new(7687, 7687), + Interval::new(7689, 7689), + Interval::new(7691, 7691), + Interval::new(7693, 7693), + Interval::new(7695, 7695), + Interval::new(7697, 7697), + Interval::new(7699, 7699), + Interval::new(7701, 7701), + Interval::new(7703, 7703), + Interval::new(7705, 7705), + Interval::new(7707, 7707), + Interval::new(7709, 7709), + Interval::new(7711, 7711), + Interval::new(7713, 7713), + Interval::new(7715, 7715), + Interval::new(7717, 7717), + Interval::new(7719, 7719), + Interval::new(7721, 7721), + Interval::new(7723, 7723), + Interval::new(7725, 7725), + Interval::new(7727, 7727), + Interval::new(7729, 7729), + Interval::new(7731, 7731), + Interval::new(7733, 7733), + Interval::new(7735, 7735), + Interval::new(7737, 7737), + Interval::new(7739, 7739), + Interval::new(7741, 7741), + Interval::new(7743, 7743), + Interval::new(7745, 7745), + Interval::new(7747, 7747), + Interval::new(7749, 7749), + Interval::new(7751, 7751), + Interval::new(7753, 7753), + Interval::new(7755, 7755), + Interval::new(7757, 7757), + Interval::new(7759, 7759), + Interval::new(7761, 7761), + Interval::new(7763, 7763), + Interval::new(7765, 7765), + Interval::new(7767, 7767), + Interval::new(7769, 7769), + Interval::new(7771, 7771), + Interval::new(7773, 7773), + Interval::new(7775, 7775), + Interval::new(7777, 7777), + Interval::new(7779, 7779), + Interval::new(7781, 7781), + Interval::new(7783, 7783), + Interval::new(7785, 7785), + Interval::new(7787, 7787), + Interval::new(7789, 7789), + Interval::new(7791, 7791), + Interval::new(7793, 7793), + Interval::new(7795, 7795), + Interval::new(7797, 7797), + Interval::new(7799, 7799), + Interval::new(7801, 7801), + Interval::new(7803, 7803), + Interval::new(7805, 7805), + Interval::new(7807, 7807), + Interval::new(7809, 7809), + Interval::new(7811, 7811), + Interval::new(7813, 7813), + Interval::new(7815, 7815), + Interval::new(7817, 7817), + Interval::new(7819, 7819), + Interval::new(7821, 7821), + Interval::new(7823, 7823), + Interval::new(7825, 7825), + Interval::new(7827, 7827), + Interval::new(7829, 7835), + Interval::new(7841, 7841), + Interval::new(7843, 7843), + Interval::new(7845, 7845), + Interval::new(7847, 7847), + Interval::new(7849, 7849), + Interval::new(7851, 7851), + Interval::new(7853, 7853), + Interval::new(7855, 7855), + Interval::new(7857, 7857), + Interval::new(7859, 7859), + Interval::new(7861, 7861), + Interval::new(7863, 7863), + Interval::new(7865, 7865), + Interval::new(7867, 7867), + Interval::new(7869, 7869), + Interval::new(7871, 7871), + Interval::new(7873, 7873), + Interval::new(7875, 7875), + Interval::new(7877, 7877), + Interval::new(7879, 7879), + Interval::new(7881, 7881), + Interval::new(7883, 7883), + Interval::new(7885, 7885), + Interval::new(7887, 7887), + Interval::new(7889, 7889), + Interval::new(7891, 7891), + Interval::new(7893, 7893), + Interval::new(7895, 7895), + Interval::new(7897, 7897), + Interval::new(7899, 7899), + Interval::new(7901, 7901), + Interval::new(7903, 7903), + Interval::new(7905, 7905), + Interval::new(7907, 7907), + Interval::new(7909, 7909), + Interval::new(7911, 7911), + Interval::new(7913, 7913), + Interval::new(7915, 7915), + Interval::new(7917, 7917), + Interval::new(7919, 7919), + Interval::new(7921, 7921), + Interval::new(7923, 7923), + Interval::new(7925, 7925), + Interval::new(7927, 7927), + Interval::new(7929, 7929), + Interval::new(7931, 7931), + Interval::new(7933, 7933), + Interval::new(7935, 7943), + Interval::new(7952, 7957), + Interval::new(7968, 7975), + Interval::new(7984, 7991), + Interval::new(8000, 8005), + Interval::new(8016, 8023), + Interval::new(8032, 8039), + Interval::new(8048, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8119), + Interval::new(8124, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8135), + Interval::new(8140, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8151), + Interval::new(8160, 8167), + Interval::new(8178, 8180), + Interval::new(8182, 8183), + Interval::new(8188, 8188), + Interval::new(8526, 8526), + Interval::new(8560, 8575), + Interval::new(8580, 8580), + Interval::new(9424, 9449), + Interval::new(11312, 11359), + Interval::new(11361, 11361), + Interval::new(11365, 11366), + Interval::new(11368, 11368), + Interval::new(11370, 11370), + Interval::new(11372, 11372), + Interval::new(11379, 11379), + Interval::new(11382, 11382), + Interval::new(11393, 11393), + Interval::new(11395, 11395), + Interval::new(11397, 11397), + Interval::new(11399, 11399), + Interval::new(11401, 11401), + Interval::new(11403, 11403), + Interval::new(11405, 11405), + Interval::new(11407, 11407), + Interval::new(11409, 11409), + Interval::new(11411, 11411), + Interval::new(11413, 11413), + Interval::new(11415, 11415), + Interval::new(11417, 11417), + Interval::new(11419, 11419), + Interval::new(11421, 11421), + Interval::new(11423, 11423), + Interval::new(11425, 11425), + Interval::new(11427, 11427), + Interval::new(11429, 11429), + Interval::new(11431, 11431), + Interval::new(11433, 11433), + Interval::new(11435, 11435), + Interval::new(11437, 11437), + Interval::new(11439, 11439), + Interval::new(11441, 11441), + Interval::new(11443, 11443), + Interval::new(11445, 11445), + Interval::new(11447, 11447), + Interval::new(11449, 11449), + Interval::new(11451, 11451), + Interval::new(11453, 11453), + Interval::new(11455, 11455), + Interval::new(11457, 11457), + Interval::new(11459, 11459), + Interval::new(11461, 11461), + Interval::new(11463, 11463), + Interval::new(11465, 11465), + Interval::new(11467, 11467), + Interval::new(11469, 11469), + Interval::new(11471, 11471), + Interval::new(11473, 11473), + Interval::new(11475, 11475), + Interval::new(11477, 11477), + Interval::new(11479, 11479), + Interval::new(11481, 11481), + Interval::new(11483, 11483), + Interval::new(11485, 11485), + Interval::new(11487, 11487), + Interval::new(11489, 11489), + Interval::new(11491, 11491), + Interval::new(11500, 11500), + Interval::new(11502, 11502), + Interval::new(11507, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42561, 42561), + Interval::new(42563, 42563), + Interval::new(42565, 42565), + Interval::new(42567, 42567), + Interval::new(42569, 42569), + Interval::new(42571, 42571), + Interval::new(42573, 42573), + Interval::new(42575, 42575), + Interval::new(42577, 42577), + Interval::new(42579, 42579), + Interval::new(42581, 42581), + Interval::new(42583, 42583), + Interval::new(42585, 42585), + Interval::new(42587, 42587), + Interval::new(42589, 42589), + Interval::new(42591, 42591), + Interval::new(42593, 42593), + Interval::new(42595, 42595), + Interval::new(42597, 42597), + Interval::new(42599, 42599), + Interval::new(42601, 42601), + Interval::new(42603, 42603), + Interval::new(42605, 42605), + Interval::new(42625, 42625), + Interval::new(42627, 42627), + Interval::new(42629, 42629), + Interval::new(42631, 42631), + Interval::new(42633, 42633), + Interval::new(42635, 42635), + Interval::new(42637, 42637), + Interval::new(42639, 42639), + Interval::new(42641, 42641), + Interval::new(42643, 42643), + Interval::new(42645, 42645), + Interval::new(42647, 42647), + Interval::new(42649, 42649), + Interval::new(42651, 42651), + Interval::new(42787, 42787), + Interval::new(42789, 42789), + Interval::new(42791, 42791), + Interval::new(42793, 42793), + Interval::new(42795, 42795), + Interval::new(42797, 42797), + Interval::new(42799, 42799), + Interval::new(42803, 42803), + Interval::new(42805, 42805), + Interval::new(42807, 42807), + Interval::new(42809, 42809), + Interval::new(42811, 42811), + Interval::new(42813, 42813), + Interval::new(42815, 42815), + Interval::new(42817, 42817), + Interval::new(42819, 42819), + Interval::new(42821, 42821), + Interval::new(42823, 42823), + Interval::new(42825, 42825), + Interval::new(42827, 42827), + Interval::new(42829, 42829), + Interval::new(42831, 42831), + Interval::new(42833, 42833), + Interval::new(42835, 42835), + Interval::new(42837, 42837), + Interval::new(42839, 42839), + Interval::new(42841, 42841), + Interval::new(42843, 42843), + Interval::new(42845, 42845), + Interval::new(42847, 42847), + Interval::new(42849, 42849), + Interval::new(42851, 42851), + Interval::new(42853, 42853), + Interval::new(42855, 42855), + Interval::new(42857, 42857), + Interval::new(42859, 42859), + Interval::new(42861, 42861), + Interval::new(42863, 42863), + Interval::new(42874, 42874), + Interval::new(42876, 42876), + Interval::new(42879, 42879), + Interval::new(42881, 42881), + Interval::new(42883, 42883), + Interval::new(42885, 42885), + Interval::new(42887, 42887), + Interval::new(42892, 42892), + Interval::new(42897, 42897), + Interval::new(42899, 42900), + Interval::new(42903, 42903), + Interval::new(42905, 42905), + Interval::new(42907, 42907), + Interval::new(42909, 42909), + Interval::new(42911, 42911), + Interval::new(42913, 42913), + Interval::new(42915, 42915), + Interval::new(42917, 42917), + Interval::new(42919, 42919), + Interval::new(42921, 42921), + Interval::new(42933, 42933), + Interval::new(42935, 42935), + Interval::new(42937, 42937), + Interval::new(42939, 42939), + Interval::new(42941, 42941), + Interval::new(42943, 42943), + Interval::new(42945, 42945), + Interval::new(42947, 42947), + Interval::new(42952, 42952), + Interval::new(42954, 42954), + Interval::new(42957, 42957), + Interval::new(42959, 42959), + Interval::new(42961, 42961), + Interval::new(42963, 42963), + Interval::new(42965, 42965), + Interval::new(42967, 42967), + Interval::new(42969, 42969), + Interval::new(42971, 42971), + Interval::new(42998, 42998), + Interval::new(43859, 43859), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65345, 65370), + Interval::new(66600, 66639), + Interval::new(66776, 66811), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(68800, 68850), + Interval::new(68976, 68997), + Interval::new(71872, 71903), + Interval::new(93792, 93823), + Interval::new(93883, 93907), + Interval::new(125218, 125251), +]; + +/// Return the code point ranges of the 'Changes_When_Uppercased' Unicode property. +pub(crate) fn changes_when_uppercased_ranges() -> &'static [Interval] { + &CHANGES_WHEN_UPPERCASED +} + +const DEFAULT_IGNORABLE_CODE_POINT: [Interval; 17] = [ + Interval::new(173, 173), + Interval::new(847, 847), + Interval::new(1564, 1564), + Interval::new(4447, 4448), + Interval::new(6068, 6069), + Interval::new(6155, 6159), + Interval::new(8203, 8207), + Interval::new(8234, 8238), + Interval::new(8288, 8303), + Interval::new(12644, 12644), + Interval::new(65024, 65039), + Interval::new(65279, 65279), + Interval::new(65440, 65440), + Interval::new(65520, 65528), + Interval::new(113824, 113827), + Interval::new(119155, 119162), + Interval::new(917504, 921599), +]; + +/// Return the code point ranges of the 'Default_Ignorable_Code_Point' Unicode property. +pub(crate) fn default_ignorable_code_point_ranges() -> &'static [Interval] { + &DEFAULT_IGNORABLE_CODE_POINT +} + +const GRAPHEME_BASE: [Interval; 904] = [ + Interval::new(32, 126), + Interval::new(160, 172), + Interval::new(174, 767), + Interval::new(880, 887), + Interval::new(890, 895), + Interval::new(900, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1154), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1418), + Interval::new(1421, 1423), + Interval::new(1470, 1470), + Interval::new(1472, 1472), + Interval::new(1475, 1475), + Interval::new(1478, 1478), + Interval::new(1488, 1514), + Interval::new(1519, 1524), + Interval::new(1542, 1551), + Interval::new(1563, 1563), + Interval::new(1565, 1610), + Interval::new(1632, 1647), + Interval::new(1649, 1749), + Interval::new(1758, 1758), + Interval::new(1765, 1766), + Interval::new(1769, 1769), + Interval::new(1774, 1805), + Interval::new(1808, 1808), + Interval::new(1810, 1839), + Interval::new(1869, 1957), + Interval::new(1969, 1969), + Interval::new(1984, 2026), + Interval::new(2036, 2042), + Interval::new(2046, 2069), + Interval::new(2074, 2074), + Interval::new(2084, 2084), + Interval::new(2088, 2088), + Interval::new(2096, 2110), + Interval::new(2112, 2136), + Interval::new(2142, 2142), + Interval::new(2144, 2154), + Interval::new(2160, 2191), + Interval::new(2208, 2249), + Interval::new(2307, 2361), + Interval::new(2363, 2363), + Interval::new(2365, 2368), + Interval::new(2377, 2380), + Interval::new(2382, 2384), + Interval::new(2392, 2401), + Interval::new(2404, 2432), + Interval::new(2434, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2493, 2493), + Interval::new(2495, 2496), + Interval::new(2503, 2504), + Interval::new(2507, 2508), + Interval::new(2510, 2510), + Interval::new(2524, 2525), + Interval::new(2527, 2529), + Interval::new(2534, 2557), + Interval::new(2563, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2622, 2624), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2662, 2671), + Interval::new(2674, 2676), + Interval::new(2678, 2678), + Interval::new(2691, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2749, 2752), + Interval::new(2761, 2761), + Interval::new(2763, 2764), + Interval::new(2768, 2768), + Interval::new(2784, 2785), + Interval::new(2790, 2801), + Interval::new(2809, 2809), + Interval::new(2818, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2877, 2877), + Interval::new(2880, 2880), + Interval::new(2887, 2888), + Interval::new(2891, 2892), + Interval::new(2908, 2909), + Interval::new(2911, 2913), + Interval::new(2918, 2935), + Interval::new(2947, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3007, 3007), + Interval::new(3009, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3020), + Interval::new(3024, 3024), + Interval::new(3046, 3066), + Interval::new(3073, 3075), + Interval::new(3077, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3133, 3133), + Interval::new(3137, 3140), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3169), + Interval::new(3174, 3183), + Interval::new(3191, 3200), + Interval::new(3202, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3261, 3262), + Interval::new(3265, 3265), + Interval::new(3267, 3268), + Interval::new(3292, 3294), + Interval::new(3296, 3297), + Interval::new(3302, 3311), + Interval::new(3313, 3315), + Interval::new(3330, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3386), + Interval::new(3389, 3389), + Interval::new(3391, 3392), + Interval::new(3398, 3400), + Interval::new(3402, 3404), + Interval::new(3406, 3407), + Interval::new(3412, 3414), + Interval::new(3416, 3425), + Interval::new(3430, 3455), + Interval::new(3458, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3536, 3537), + Interval::new(3544, 3550), + Interval::new(3558, 3567), + Interval::new(3570, 3572), + Interval::new(3585, 3632), + Interval::new(3634, 3635), + Interval::new(3647, 3654), + Interval::new(3663, 3675), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3760), + Interval::new(3762, 3763), + Interval::new(3773, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3792, 3801), + Interval::new(3804, 3807), + Interval::new(3840, 3863), + Interval::new(3866, 3892), + Interval::new(3894, 3894), + Interval::new(3896, 3896), + Interval::new(3898, 3911), + Interval::new(3913, 3948), + Interval::new(3967, 3967), + Interval::new(3973, 3973), + Interval::new(3976, 3980), + Interval::new(4030, 4037), + Interval::new(4039, 4044), + Interval::new(4046, 4058), + Interval::new(4096, 4140), + Interval::new(4145, 4145), + Interval::new(4152, 4152), + Interval::new(4155, 4156), + Interval::new(4159, 4183), + Interval::new(4186, 4189), + Interval::new(4193, 4208), + Interval::new(4213, 4225), + Interval::new(4227, 4228), + Interval::new(4231, 4236), + Interval::new(4238, 4252), + Interval::new(4254, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4960, 4988), + Interval::new(4992, 5017), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5120, 5788), + Interval::new(5792, 5880), + Interval::new(5888, 5905), + Interval::new(5919, 5937), + Interval::new(5941, 5942), + Interval::new(5952, 5969), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6016, 6067), + Interval::new(6070, 6070), + Interval::new(6078, 6085), + Interval::new(6087, 6088), + Interval::new(6100, 6108), + Interval::new(6112, 6121), + Interval::new(6128, 6137), + Interval::new(6144, 6154), + Interval::new(6160, 6169), + Interval::new(6176, 6264), + Interval::new(6272, 6276), + Interval::new(6279, 6312), + Interval::new(6314, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6435, 6438), + Interval::new(6441, 6443), + Interval::new(6448, 6449), + Interval::new(6451, 6456), + Interval::new(6464, 6464), + Interval::new(6468, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6608, 6618), + Interval::new(6622, 6678), + Interval::new(6681, 6682), + Interval::new(6686, 6741), + Interval::new(6743, 6743), + Interval::new(6753, 6753), + Interval::new(6755, 6756), + Interval::new(6765, 6770), + Interval::new(6784, 6793), + Interval::new(6800, 6809), + Interval::new(6816, 6829), + Interval::new(6916, 6963), + Interval::new(6974, 6977), + Interval::new(6981, 6988), + Interval::new(6990, 7018), + Interval::new(7028, 7039), + Interval::new(7042, 7073), + Interval::new(7078, 7079), + Interval::new(7086, 7141), + Interval::new(7143, 7143), + Interval::new(7146, 7148), + Interval::new(7150, 7150), + Interval::new(7164, 7211), + Interval::new(7220, 7221), + Interval::new(7227, 7241), + Interval::new(7245, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7367), + Interval::new(7379, 7379), + Interval::new(7393, 7393), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7415), + Interval::new(7418, 7418), + Interval::new(7424, 7615), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8132), + Interval::new(8134, 8147), + Interval::new(8150, 8155), + Interval::new(8157, 8175), + Interval::new(8178, 8180), + Interval::new(8182, 8190), + Interval::new(8192, 8202), + Interval::new(8208, 8231), + Interval::new(8239, 8287), + Interval::new(8304, 8305), + Interval::new(8308, 8334), + Interval::new(8336, 8348), + Interval::new(8352, 8385), + Interval::new(8448, 8587), + Interval::new(8592, 9257), + Interval::new(9280, 9290), + Interval::new(9312, 11123), + Interval::new(11126, 11502), + Interval::new(11506, 11507), + Interval::new(11513, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11632), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(11776, 11869), + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), + Interval::new(12272, 12329), + Interval::new(12336, 12351), + Interval::new(12353, 12438), + Interval::new(12443, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12688, 12773), + Interval::new(12783, 12830), + Interval::new(12832, 42124), + Interval::new(42128, 42182), + Interval::new(42192, 42539), + Interval::new(42560, 42606), + Interval::new(42611, 42611), + Interval::new(42622, 42653), + Interval::new(42656, 42735), + Interval::new(42738, 42743), + Interval::new(42752, 42972), + Interval::new(42993, 43009), + Interval::new(43011, 43013), + Interval::new(43015, 43018), + Interval::new(43020, 43044), + Interval::new(43047, 43051), + Interval::new(43056, 43065), + Interval::new(43072, 43127), + Interval::new(43136, 43203), + Interval::new(43214, 43225), + Interval::new(43250, 43262), + Interval::new(43264, 43301), + Interval::new(43310, 43334), + Interval::new(43346, 43346), + Interval::new(43359, 43388), + Interval::new(43395, 43442), + Interval::new(43444, 43445), + Interval::new(43450, 43451), + Interval::new(43454, 43455), + Interval::new(43457, 43469), + Interval::new(43471, 43481), + Interval::new(43486, 43492), + Interval::new(43494, 43518), + Interval::new(43520, 43560), + Interval::new(43567, 43568), + Interval::new(43571, 43572), + Interval::new(43584, 43586), + Interval::new(43588, 43595), + Interval::new(43597, 43597), + Interval::new(43600, 43609), + Interval::new(43612, 43643), + Interval::new(43645, 43695), + Interval::new(43697, 43697), + Interval::new(43701, 43702), + Interval::new(43705, 43709), + Interval::new(43712, 43712), + Interval::new(43714, 43714), + Interval::new(43739, 43755), + Interval::new(43758, 43765), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43883), + Interval::new(43888, 44004), + Interval::new(44006, 44007), + Interval::new(44009, 44012), + Interval::new(44016, 44025), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64285), + Interval::new(64287, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64975), + Interval::new(65008, 65023), + Interval::new(65040, 65049), + Interval::new(65072, 65106), + Interval::new(65108, 65126), + Interval::new(65128, 65131), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65281, 65437), + Interval::new(65440, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65504, 65510), + Interval::new(65512, 65518), + Interval::new(65532, 65533), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65792, 65794), + Interval::new(65799, 65843), + Interval::new(65847, 65934), + Interval::new(65936, 65948), + Interval::new(65952, 65952), + Interval::new(66000, 66044), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66273, 66299), + Interval::new(66304, 66339), + Interval::new(66349, 66378), + Interval::new(66384, 66421), + Interval::new(66432, 66461), + Interval::new(66463, 66499), + Interval::new(66504, 66517), + Interval::new(66560, 66717), + Interval::new(66720, 66729), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66927, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67671, 67742), + Interval::new(67751, 67759), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67835, 67867), + Interval::new(67871, 67897), + Interval::new(67903, 67929), + Interval::new(67968, 68023), + Interval::new(68028, 68047), + Interval::new(68050, 68096), + Interval::new(68112, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68160, 68168), + Interval::new(68176, 68184), + Interval::new(68192, 68255), + Interval::new(68288, 68324), + Interval::new(68331, 68342), + Interval::new(68352, 68405), + Interval::new(68409, 68437), + Interval::new(68440, 68466), + Interval::new(68472, 68497), + Interval::new(68505, 68508), + Interval::new(68521, 68527), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68858, 68899), + Interval::new(68912, 68921), + Interval::new(68928, 68965), + Interval::new(68974, 68997), + Interval::new(69006, 69007), + Interval::new(69216, 69246), + Interval::new(69248, 69289), + Interval::new(69293, 69293), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69328, 69336), + Interval::new(69376, 69415), + Interval::new(69424, 69445), + Interval::new(69457, 69465), + Interval::new(69488, 69505), + Interval::new(69510, 69513), + Interval::new(69552, 69579), + Interval::new(69600, 69622), + Interval::new(69632, 69632), + Interval::new(69634, 69687), + Interval::new(69703, 69709), + Interval::new(69714, 69743), + Interval::new(69745, 69746), + Interval::new(69749, 69749), + Interval::new(69762, 69810), + Interval::new(69815, 69816), + Interval::new(69819, 69820), + Interval::new(69822, 69825), + Interval::new(69840, 69864), + Interval::new(69872, 69881), + Interval::new(69891, 69926), + Interval::new(69932, 69932), + Interval::new(69942, 69959), + Interval::new(69968, 70002), + Interval::new(70004, 70006), + Interval::new(70018, 70069), + Interval::new(70079, 70079), + Interval::new(70081, 70088), + Interval::new(70093, 70094), + Interval::new(70096, 70111), + Interval::new(70113, 70132), + Interval::new(70144, 70161), + Interval::new(70163, 70190), + Interval::new(70194, 70195), + Interval::new(70200, 70205), + Interval::new(70207, 70208), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70313), + Interval::new(70320, 70366), + Interval::new(70368, 70370), + Interval::new(70384, 70393), + Interval::new(70402, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70461, 70461), + Interval::new(70463, 70463), + Interval::new(70465, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70476), + Interval::new(70480, 70480), + Interval::new(70493, 70499), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70583), + Interval::new(70585, 70586), + Interval::new(70602, 70602), + Interval::new(70604, 70605), + Interval::new(70609, 70609), + Interval::new(70611, 70613), + Interval::new(70615, 70616), + Interval::new(70656, 70711), + Interval::new(70720, 70721), + Interval::new(70725, 70725), + Interval::new(70727, 70747), + Interval::new(70749, 70749), + Interval::new(70751, 70753), + Interval::new(70784, 70831), + Interval::new(70833, 70834), + Interval::new(70841, 70841), + Interval::new(70843, 70844), + Interval::new(70846, 70846), + Interval::new(70849, 70849), + Interval::new(70852, 70855), + Interval::new(70864, 70873), + Interval::new(71040, 71086), + Interval::new(71088, 71089), + Interval::new(71096, 71099), + Interval::new(71102, 71102), + Interval::new(71105, 71131), + Interval::new(71168, 71218), + Interval::new(71227, 71228), + Interval::new(71230, 71230), + Interval::new(71233, 71236), + Interval::new(71248, 71257), + Interval::new(71264, 71276), + Interval::new(71296, 71338), + Interval::new(71340, 71340), + Interval::new(71342, 71343), + Interval::new(71352, 71353), + Interval::new(71360, 71369), + Interval::new(71376, 71395), + Interval::new(71424, 71450), + Interval::new(71454, 71454), + Interval::new(71456, 71457), + Interval::new(71462, 71462), + Interval::new(71472, 71494), + Interval::new(71680, 71726), + Interval::new(71736, 71736), + Interval::new(71739, 71739), + Interval::new(71840, 71922), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71983), + Interval::new(71985, 71989), + Interval::new(71991, 71992), + Interval::new(71999, 72002), + Interval::new(72004, 72006), + Interval::new(72016, 72025), + Interval::new(72096, 72103), + Interval::new(72106, 72147), + Interval::new(72156, 72159), + Interval::new(72161, 72164), + Interval::new(72192, 72192), + Interval::new(72203, 72242), + Interval::new(72249, 72250), + Interval::new(72255, 72262), + Interval::new(72272, 72272), + Interval::new(72279, 72280), + Interval::new(72284, 72329), + Interval::new(72343, 72343), + Interval::new(72346, 72354), + Interval::new(72368, 72440), + Interval::new(72448, 72457), + Interval::new(72545, 72545), + Interval::new(72549, 72549), + Interval::new(72551, 72551), + Interval::new(72640, 72673), + Interval::new(72688, 72697), + Interval::new(72704, 72712), + Interval::new(72714, 72751), + Interval::new(72766, 72766), + Interval::new(72768, 72773), + Interval::new(72784, 72812), + Interval::new(72816, 72847), + Interval::new(72873, 72873), + Interval::new(72881, 72881), + Interval::new(72884, 72884), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73008), + Interval::new(73030, 73030), + Interval::new(73040, 73049), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73107, 73108), + Interval::new(73110, 73110), + Interval::new(73112, 73112), + Interval::new(73120, 73129), + Interval::new(73136, 73179), + Interval::new(73184, 73193), + Interval::new(73440, 73458), + Interval::new(73461, 73464), + Interval::new(73474, 73488), + Interval::new(73490, 73525), + Interval::new(73534, 73535), + Interval::new(73539, 73561), + Interval::new(73648, 73648), + Interval::new(73664, 73713), + Interval::new(73727, 74649), + Interval::new(74752, 74862), + Interval::new(74864, 74868), + Interval::new(74880, 75075), + Interval::new(77712, 77810), + Interval::new(77824, 78895), + Interval::new(78913, 78918), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90397), + Interval::new(90410, 90412), + Interval::new(90416, 90425), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92768, 92777), + Interval::new(92782, 92862), + Interval::new(92864, 92873), + Interval::new(92880, 92909), + Interval::new(92917, 92917), + Interval::new(92928, 92975), + Interval::new(92983, 92997), + Interval::new(93008, 93017), + Interval::new(93019, 93025), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93561), + Interval::new(93760, 93850), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94032, 94087), + Interval::new(94099, 94111), + Interval::new(94176, 94179), + Interval::new(94194, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113820, 113820), + Interval::new(113823, 113823), + Interval::new(117760, 118012), + Interval::new(118016, 118451), + Interval::new(118458, 118480), + Interval::new(118496, 118512), + Interval::new(118608, 118723), + Interval::new(118784, 119029), + Interval::new(119040, 119078), + Interval::new(119081, 119140), + Interval::new(119146, 119148), + Interval::new(119171, 119172), + Interval::new(119180, 119209), + Interval::new(119214, 119274), + Interval::new(119296, 119361), + Interval::new(119365, 119365), + Interval::new(119488, 119507), + Interval::new(119520, 119539), + Interval::new(119552, 119638), + Interval::new(119648, 119672), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120779), + Interval::new(120782, 121343), + Interval::new(121399, 121402), + Interval::new(121453, 121460), + Interval::new(121462, 121475), + Interval::new(121477, 121483), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122928, 122989), + Interval::new(123136, 123180), + Interval::new(123191, 123197), + Interval::new(123200, 123209), + Interval::new(123214, 123215), + Interval::new(123536, 123565), + Interval::new(123584, 123627), + Interval::new(123632, 123641), + Interval::new(123647, 123647), + Interval::new(124112, 124139), + Interval::new(124144, 124153), + Interval::new(124368, 124397), + Interval::new(124400, 124410), + Interval::new(124415, 124415), + Interval::new(124608, 124638), + Interval::new(124640, 124642), + Interval::new(124644, 124645), + Interval::new(124647, 124653), + Interval::new(124656, 124660), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125127, 125135), + Interval::new(125184, 125251), + Interval::new(125259, 125259), + Interval::new(125264, 125273), + Interval::new(125278, 125279), + Interval::new(126065, 126132), + Interval::new(126209, 126269), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(126704, 126705), + Interval::new(126976, 127019), + Interval::new(127024, 127123), + Interval::new(127136, 127150), + Interval::new(127153, 127167), + Interval::new(127169, 127183), + Interval::new(127185, 127221), + Interval::new(127232, 127405), + Interval::new(127462, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127568, 127569), + Interval::new(127584, 127589), + Interval::new(127744, 128728), + Interval::new(128732, 128748), + Interval::new(128752, 128764), + Interval::new(128768, 128985), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129024, 129035), + Interval::new(129040, 129095), + Interval::new(129104, 129113), + Interval::new(129120, 129159), + Interval::new(129168, 129197), + Interval::new(129200, 129211), + Interval::new(129216, 129217), + Interval::new(129232, 129240), + Interval::new(129280, 129623), + Interval::new(129632, 129645), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), + Interval::new(129792, 129938), + Interval::new(129940, 130042), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'Grapheme_Base' Unicode property. +pub(crate) fn grapheme_base_ranges() -> &'static [Interval] { + &GRAPHEME_BASE +} + +const GRAPHEME_EXTEND: [Interval; 383] = [ + Interval::new(768, 879), + Interval::new(1155, 1161), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1552, 1562), + Interval::new(1611, 1631), + Interval::new(1648, 1648), + Interval::new(1750, 1756), + Interval::new(1759, 1764), + Interval::new(1767, 1768), + Interval::new(1770, 1773), + Interval::new(1809, 1809), + Interval::new(1840, 1866), + Interval::new(1958, 1968), + Interval::new(2027, 2035), + Interval::new(2045, 2045), + Interval::new(2070, 2073), + Interval::new(2075, 2083), + Interval::new(2085, 2087), + Interval::new(2089, 2093), + Interval::new(2137, 2139), + Interval::new(2199, 2207), + Interval::new(2250, 2273), + Interval::new(2275, 2306), + Interval::new(2362, 2362), + Interval::new(2364, 2364), + Interval::new(2369, 2376), + Interval::new(2381, 2381), + Interval::new(2385, 2391), + Interval::new(2402, 2403), + Interval::new(2433, 2433), + Interval::new(2492, 2492), + Interval::new(2494, 2494), + Interval::new(2497, 2500), + Interval::new(2509, 2509), + Interval::new(2519, 2519), + Interval::new(2530, 2531), + Interval::new(2558, 2558), + Interval::new(2561, 2562), + Interval::new(2620, 2620), + Interval::new(2625, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2672, 2673), + Interval::new(2677, 2677), + Interval::new(2689, 2690), + Interval::new(2748, 2748), + Interval::new(2753, 2757), + Interval::new(2759, 2760), + Interval::new(2765, 2765), + Interval::new(2786, 2787), + Interval::new(2810, 2815), + Interval::new(2817, 2817), + Interval::new(2876, 2876), + Interval::new(2878, 2879), + Interval::new(2881, 2884), + Interval::new(2893, 2893), + Interval::new(2901, 2903), + Interval::new(2914, 2915), + Interval::new(2946, 2946), + Interval::new(3006, 3006), + Interval::new(3008, 3008), + Interval::new(3021, 3021), + Interval::new(3031, 3031), + Interval::new(3072, 3072), + Interval::new(3076, 3076), + Interval::new(3132, 3132), + Interval::new(3134, 3136), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3170, 3171), + Interval::new(3201, 3201), + Interval::new(3260, 3260), + Interval::new(3263, 3264), + Interval::new(3266, 3266), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3298, 3299), + Interval::new(3328, 3329), + Interval::new(3387, 3388), + Interval::new(3390, 3390), + Interval::new(3393, 3396), + Interval::new(3405, 3405), + Interval::new(3415, 3415), + Interval::new(3426, 3427), + Interval::new(3457, 3457), + Interval::new(3530, 3530), + Interval::new(3535, 3535), + Interval::new(3538, 3540), + Interval::new(3542, 3542), + Interval::new(3551, 3551), + Interval::new(3633, 3633), + Interval::new(3636, 3642), + Interval::new(3655, 3662), + Interval::new(3761, 3761), + Interval::new(3764, 3772), + Interval::new(3784, 3790), + Interval::new(3864, 3865), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3953, 3966), + Interval::new(3968, 3972), + Interval::new(3974, 3975), + Interval::new(3981, 3991), + Interval::new(3993, 4028), + Interval::new(4038, 4038), + Interval::new(4141, 4144), + Interval::new(4146, 4151), + Interval::new(4153, 4154), + Interval::new(4157, 4158), + Interval::new(4184, 4185), + Interval::new(4190, 4192), + Interval::new(4209, 4212), + Interval::new(4226, 4226), + Interval::new(4229, 4230), + Interval::new(4237, 4237), + Interval::new(4253, 4253), + Interval::new(4957, 4959), + Interval::new(5906, 5909), + Interval::new(5938, 5940), + Interval::new(5970, 5971), + Interval::new(6002, 6003), + Interval::new(6068, 6069), + Interval::new(6071, 6077), + Interval::new(6086, 6086), + Interval::new(6089, 6099), + Interval::new(6109, 6109), + Interval::new(6155, 6157), + Interval::new(6159, 6159), + Interval::new(6277, 6278), + Interval::new(6313, 6313), + Interval::new(6432, 6434), + Interval::new(6439, 6440), + Interval::new(6450, 6450), + Interval::new(6457, 6459), + Interval::new(6679, 6680), + Interval::new(6683, 6683), + Interval::new(6742, 6742), + Interval::new(6744, 6750), + Interval::new(6752, 6752), + Interval::new(6754, 6754), + Interval::new(6757, 6764), + Interval::new(6771, 6780), + Interval::new(6783, 6783), + Interval::new(6832, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6915), + Interval::new(6964, 6973), + Interval::new(6978, 6980), + Interval::new(7019, 7027), + Interval::new(7040, 7041), + Interval::new(7074, 7077), + Interval::new(7080, 7085), + Interval::new(7142, 7142), + Interval::new(7144, 7145), + Interval::new(7149, 7149), + Interval::new(7151, 7155), + Interval::new(7212, 7219), + Interval::new(7222, 7223), + Interval::new(7376, 7378), + Interval::new(7380, 7392), + Interval::new(7394, 7400), + Interval::new(7405, 7405), + Interval::new(7412, 7412), + Interval::new(7416, 7417), + Interval::new(7616, 7679), + Interval::new(8204, 8204), + Interval::new(8400, 8432), + Interval::new(11503, 11505), + Interval::new(11647, 11647), + Interval::new(11744, 11775), + Interval::new(12330, 12335), + Interval::new(12441, 12442), + Interval::new(42607, 42610), + Interval::new(42612, 42621), + Interval::new(42654, 42655), + Interval::new(42736, 42737), + Interval::new(43010, 43010), + Interval::new(43014, 43014), + Interval::new(43019, 43019), + Interval::new(43045, 43046), + Interval::new(43052, 43052), + Interval::new(43204, 43205), + Interval::new(43232, 43249), + Interval::new(43263, 43263), + Interval::new(43302, 43309), + Interval::new(43335, 43345), + Interval::new(43347, 43347), + Interval::new(43392, 43394), + Interval::new(43443, 43443), + Interval::new(43446, 43449), + Interval::new(43452, 43453), + Interval::new(43456, 43456), + Interval::new(43493, 43493), + Interval::new(43561, 43566), + Interval::new(43569, 43570), + Interval::new(43573, 43574), + Interval::new(43587, 43587), + Interval::new(43596, 43596), + Interval::new(43644, 43644), + Interval::new(43696, 43696), + Interval::new(43698, 43700), + Interval::new(43703, 43704), + Interval::new(43710, 43711), + Interval::new(43713, 43713), + Interval::new(43756, 43757), + Interval::new(43766, 43766), + Interval::new(44005, 44005), + Interval::new(44008, 44008), + Interval::new(44013, 44013), + Interval::new(64286, 64286), + Interval::new(65024, 65039), + Interval::new(65056, 65071), + Interval::new(65438, 65439), + Interval::new(66045, 66045), + Interval::new(66272, 66272), + Interval::new(66422, 66426), + Interval::new(68097, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68111), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68325, 68326), + Interval::new(68900, 68903), + Interval::new(68969, 68973), + Interval::new(69291, 69292), + Interval::new(69370, 69375), + Interval::new(69446, 69456), + Interval::new(69506, 69509), + Interval::new(69633, 69633), + Interval::new(69688, 69702), + Interval::new(69744, 69744), + Interval::new(69747, 69748), + Interval::new(69759, 69761), + Interval::new(69811, 69814), + Interval::new(69817, 69818), + Interval::new(69826, 69826), + Interval::new(69888, 69890), + Interval::new(69927, 69931), + Interval::new(69933, 69940), + Interval::new(70003, 70003), + Interval::new(70016, 70017), + Interval::new(70070, 70078), + Interval::new(70080, 70080), + Interval::new(70089, 70092), + Interval::new(70095, 70095), + Interval::new(70191, 70193), + Interval::new(70196, 70199), + Interval::new(70206, 70206), + Interval::new(70209, 70209), + Interval::new(70367, 70367), + Interval::new(70371, 70378), + Interval::new(70400, 70401), + Interval::new(70459, 70460), + Interval::new(70462, 70462), + Interval::new(70464, 70464), + Interval::new(70477, 70477), + Interval::new(70487, 70487), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70584, 70584), + Interval::new(70587, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70601), + Interval::new(70606, 70608), + Interval::new(70610, 70610), + Interval::new(70625, 70626), + Interval::new(70712, 70719), + Interval::new(70722, 70724), + Interval::new(70726, 70726), + Interval::new(70750, 70750), + Interval::new(70832, 70832), + Interval::new(70835, 70840), + Interval::new(70842, 70842), + Interval::new(70845, 70845), + Interval::new(70847, 70848), + Interval::new(70850, 70851), + Interval::new(71087, 71087), + Interval::new(71090, 71093), + Interval::new(71100, 71101), + Interval::new(71103, 71104), + Interval::new(71132, 71133), + Interval::new(71219, 71226), + Interval::new(71229, 71229), + Interval::new(71231, 71232), + Interval::new(71339, 71339), + Interval::new(71341, 71341), + Interval::new(71344, 71351), + Interval::new(71453, 71453), + Interval::new(71455, 71455), + Interval::new(71458, 71461), + Interval::new(71463, 71467), + Interval::new(71727, 71735), + Interval::new(71737, 71738), + Interval::new(71984, 71984), + Interval::new(71995, 71998), + Interval::new(72003, 72003), + Interval::new(72148, 72151), + Interval::new(72154, 72155), + Interval::new(72160, 72160), + Interval::new(72193, 72202), + Interval::new(72243, 72248), + Interval::new(72251, 72254), + Interval::new(72263, 72263), + Interval::new(72273, 72278), + Interval::new(72281, 72283), + Interval::new(72330, 72342), + Interval::new(72344, 72345), + Interval::new(72544, 72544), + Interval::new(72546, 72548), + Interval::new(72550, 72550), + Interval::new(72752, 72758), + Interval::new(72760, 72765), + Interval::new(72767, 72767), + Interval::new(72850, 72871), + Interval::new(72874, 72880), + Interval::new(72882, 72883), + Interval::new(72885, 72886), + Interval::new(73009, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73029), + Interval::new(73031, 73031), + Interval::new(73104, 73105), + Interval::new(73109, 73109), + Interval::new(73111, 73111), + Interval::new(73459, 73460), + Interval::new(73472, 73473), + Interval::new(73526, 73530), + Interval::new(73536, 73538), + Interval::new(73562, 73562), + Interval::new(78912, 78912), + Interval::new(78919, 78933), + Interval::new(90398, 90409), + Interval::new(90413, 90415), + Interval::new(92912, 92916), + Interval::new(92976, 92982), + Interval::new(94031, 94031), + Interval::new(94095, 94098), + Interval::new(94180, 94180), + Interval::new(94192, 94193), + Interval::new(113821, 113822), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119141, 119145), + Interval::new(119149, 119154), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(119362, 119364), + Interval::new(121344, 121398), + Interval::new(121403, 121452), + Interval::new(121461, 121461), + Interval::new(121476, 121476), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(123023, 123023), + Interval::new(123184, 123190), + Interval::new(123566, 123566), + Interval::new(123628, 123631), + Interval::new(124140, 124143), + Interval::new(124398, 124399), + Interval::new(124643, 124643), + Interval::new(124646, 124646), + Interval::new(124654, 124655), + Interval::new(124661, 124661), + Interval::new(125136, 125142), + Interval::new(125252, 125258), + Interval::new(917536, 917631), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'Grapheme_Extend' Unicode property. +pub(crate) fn grapheme_extend_ranges() -> &'static [Interval] { + &GRAPHEME_EXTEND +} + +const ID_CONTINUE: [Interval; 799] = [ + Interval::new(48, 57), + Interval::new(65, 90), + Interval::new(95, 95), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(183, 183), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(768, 884), + Interval::new(886, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(902, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1155, 1159), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1369), + Interval::new(1376, 1416), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1552, 1562), + Interval::new(1568, 1641), + Interval::new(1646, 1747), + Interval::new(1749, 1756), + Interval::new(1759, 1768), + Interval::new(1770, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1866), + Interval::new(1869, 1969), + Interval::new(1984, 2037), + Interval::new(2042, 2042), + Interval::new(2045, 2045), + Interval::new(2048, 2093), + Interval::new(2112, 2139), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2199, 2273), + Interval::new(2275, 2403), + Interval::new(2406, 2415), + Interval::new(2417, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2492, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2510), + Interval::new(2519, 2519), + Interval::new(2524, 2525), + Interval::new(2527, 2531), + Interval::new(2534, 2545), + Interval::new(2556, 2556), + Interval::new(2558, 2558), + Interval::new(2561, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2620, 2620), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2662, 2677), + Interval::new(2689, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2748, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2765), + Interval::new(2768, 2768), + Interval::new(2784, 2787), + Interval::new(2790, 2799), + Interval::new(2809, 2815), + Interval::new(2817, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2876, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2893), + Interval::new(2901, 2903), + Interval::new(2908, 2909), + Interval::new(2911, 2915), + Interval::new(2918, 2927), + Interval::new(2929, 2929), + Interval::new(2946, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3021), + Interval::new(3024, 3024), + Interval::new(3031, 3031), + Interval::new(3046, 3055), + Interval::new(3072, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3132, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3171), + Interval::new(3174, 3183), + Interval::new(3200, 3203), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3260, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3292, 3294), + Interval::new(3296, 3299), + Interval::new(3302, 3311), + Interval::new(3313, 3315), + Interval::new(3328, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3406), + Interval::new(3412, 3415), + Interval::new(3423, 3427), + Interval::new(3430, 3439), + Interval::new(3450, 3455), + Interval::new(3457, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3530, 3530), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3558, 3567), + Interval::new(3570, 3571), + Interval::new(3585, 3642), + Interval::new(3648, 3662), + Interval::new(3664, 3673), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3784, 3790), + Interval::new(3792, 3801), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3864, 3865), + Interval::new(3872, 3881), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3902, 3911), + Interval::new(3913, 3948), + Interval::new(3953, 3972), + Interval::new(3974, 3991), + Interval::new(3993, 4028), + Interval::new(4038, 4038), + Interval::new(4096, 4169), + Interval::new(4176, 4253), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4957, 4959), + Interval::new(4969, 4977), + Interval::new(4992, 5007), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5870, 5880), + Interval::new(5888, 5909), + Interval::new(5919, 5940), + Interval::new(5952, 5971), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6002, 6003), + Interval::new(6016, 6099), + Interval::new(6103, 6103), + Interval::new(6108, 6109), + Interval::new(6112, 6121), + Interval::new(6155, 6157), + Interval::new(6159, 6169), + Interval::new(6176, 6264), + Interval::new(6272, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6432, 6443), + Interval::new(6448, 6459), + Interval::new(6470, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6608, 6618), + Interval::new(6656, 6683), + Interval::new(6688, 6750), + Interval::new(6752, 6780), + Interval::new(6783, 6793), + Interval::new(6800, 6809), + Interval::new(6823, 6823), + Interval::new(6832, 6845), + Interval::new(6847, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6988), + Interval::new(6992, 7001), + Interval::new(7019, 7027), + Interval::new(7040, 7155), + Interval::new(7168, 7223), + Interval::new(7232, 7241), + Interval::new(7245, 7293), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7376, 7378), + Interval::new(7380, 7418), + Interval::new(7424, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8204, 8205), + Interval::new(8255, 8256), + Interval::new(8276, 8276), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8400, 8412), + Interval::new(8417, 8417), + Interval::new(8421, 8432), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8472, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(11264, 11492), + Interval::new(11499, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11631), + Interval::new(11647, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(11744, 11775), + Interval::new(12293, 12295), + Interval::new(12321, 12335), + Interval::new(12337, 12341), + Interval::new(12344, 12348), + Interval::new(12353, 12438), + Interval::new(12441, 12447), + Interval::new(12449, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 42124), + Interval::new(42192, 42237), + Interval::new(42240, 42508), + Interval::new(42512, 42539), + Interval::new(42560, 42607), + Interval::new(42612, 42621), + Interval::new(42623, 42737), + Interval::new(42775, 42783), + Interval::new(42786, 42888), + Interval::new(42891, 42972), + Interval::new(42993, 43047), + Interval::new(43052, 43052), + Interval::new(43072, 43123), + Interval::new(43136, 43205), + Interval::new(43216, 43225), + Interval::new(43232, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43309), + Interval::new(43312, 43347), + Interval::new(43360, 43388), + Interval::new(43392, 43456), + Interval::new(43471, 43481), + Interval::new(43488, 43518), + Interval::new(43520, 43574), + Interval::new(43584, 43597), + Interval::new(43600, 43609), + Interval::new(43616, 43638), + Interval::new(43642, 43714), + Interval::new(43739, 43741), + Interval::new(43744, 43759), + Interval::new(43762, 43766), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 44010), + Interval::new(44012, 44013), + Interval::new(44016, 44025), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65019), + Interval::new(65024, 65039), + Interval::new(65056, 65071), + Interval::new(65075, 65076), + Interval::new(65101, 65103), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65296, 65305), + Interval::new(65313, 65338), + Interval::new(65343, 65343), + Interval::new(65345, 65370), + Interval::new(65381, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65856, 65908), + Interval::new(66045, 66045), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66272, 66272), + Interval::new(66304, 66335), + Interval::new(66349, 66378), + Interval::new(66384, 66426), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66513, 66517), + Interval::new(66560, 66717), + Interval::new(66720, 66729), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68326), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68864, 68903), + Interval::new(68912, 68921), + Interval::new(68928, 68965), + Interval::new(68969, 68973), + Interval::new(68975, 68997), + Interval::new(69248, 69289), + Interval::new(69291, 69292), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69370, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69456), + Interval::new(69488, 69509), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69632, 69702), + Interval::new(69734, 69749), + Interval::new(69759, 69818), + Interval::new(69826, 69826), + Interval::new(69840, 69864), + Interval::new(69872, 69881), + Interval::new(69888, 69940), + Interval::new(69942, 69951), + Interval::new(69956, 69959), + Interval::new(69968, 70003), + Interval::new(70006, 70006), + Interval::new(70016, 70084), + Interval::new(70089, 70092), + Interval::new(70094, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70199), + Interval::new(70206, 70209), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70378), + Interval::new(70384, 70393), + Interval::new(70400, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70459, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70480, 70480), + Interval::new(70487, 70487), + Interval::new(70493, 70499), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70611), + Interval::new(70625, 70626), + Interval::new(70656, 70730), + Interval::new(70736, 70745), + Interval::new(70750, 70753), + Interval::new(70784, 70853), + Interval::new(70855, 70855), + Interval::new(70864, 70873), + Interval::new(71040, 71093), + Interval::new(71096, 71104), + Interval::new(71128, 71133), + Interval::new(71168, 71232), + Interval::new(71236, 71236), + Interval::new(71248, 71257), + Interval::new(71296, 71352), + Interval::new(71360, 71369), + Interval::new(71376, 71395), + Interval::new(71424, 71450), + Interval::new(71453, 71467), + Interval::new(71472, 71481), + Interval::new(71488, 71494), + Interval::new(71680, 71738), + Interval::new(71840, 71913), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71989), + Interval::new(71991, 71992), + Interval::new(71995, 72003), + Interval::new(72016, 72025), + Interval::new(72096, 72103), + Interval::new(72106, 72151), + Interval::new(72154, 72161), + Interval::new(72163, 72164), + Interval::new(72192, 72254), + Interval::new(72263, 72263), + Interval::new(72272, 72345), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72544, 72551), + Interval::new(72640, 72672), + Interval::new(72688, 72697), + Interval::new(72704, 72712), + Interval::new(72714, 72758), + Interval::new(72760, 72768), + Interval::new(72784, 72793), + Interval::new(72818, 72847), + Interval::new(72850, 72871), + Interval::new(72873, 72886), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73031), + Interval::new(73040, 73049), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73112), + Interval::new(73120, 73129), + Interval::new(73136, 73179), + Interval::new(73184, 73193), + Interval::new(73440, 73462), + Interval::new(73472, 73488), + Interval::new(73490, 73530), + Interval::new(73534, 73538), + Interval::new(73552, 73562), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74752, 74862), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78912, 78933), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90425), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92768, 92777), + Interval::new(92784, 92862), + Interval::new(92864, 92873), + Interval::new(92880, 92909), + Interval::new(92912, 92916), + Interval::new(92928, 92982), + Interval::new(92992, 92995), + Interval::new(93008, 93017), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93548), + Interval::new(93552, 93561), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94031, 94087), + Interval::new(94095, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94180), + Interval::new(94192, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113821, 113822), + Interval::new(118000, 118009), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119141, 119145), + Interval::new(119149, 119154), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(119362, 119364), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(120782, 120831), + Interval::new(121344, 121398), + Interval::new(121403, 121452), + Interval::new(121461, 121461), + Interval::new(121476, 121476), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(122928, 122989), + Interval::new(123023, 123023), + Interval::new(123136, 123180), + Interval::new(123184, 123197), + Interval::new(123200, 123209), + Interval::new(123214, 123214), + Interval::new(123536, 123566), + Interval::new(123584, 123641), + Interval::new(124112, 124153), + Interval::new(124368, 124410), + Interval::new(124608, 124638), + Interval::new(124640, 124661), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125136, 125142), + Interval::new(125184, 125259), + Interval::new(125264, 125273), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(130032, 130041), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'ID_Continue' Unicode property. +pub(crate) fn id_continue_ranges() -> &'static [Interval] { + &ID_CONTINUE +} + +const ID_START: [Interval; 684] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(880, 884), + Interval::new(886, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1369), + Interval::new(1376, 1416), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1568, 1610), + Interval::new(1646, 1647), + Interval::new(1649, 1747), + Interval::new(1749, 1749), + Interval::new(1765, 1766), + Interval::new(1774, 1775), + Interval::new(1786, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1808), + Interval::new(1810, 1839), + Interval::new(1869, 1957), + Interval::new(1969, 1969), + Interval::new(1994, 2026), + Interval::new(2036, 2037), + Interval::new(2042, 2042), + Interval::new(2048, 2069), + Interval::new(2074, 2074), + Interval::new(2084, 2084), + Interval::new(2088, 2088), + Interval::new(2112, 2136), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2208, 2249), + Interval::new(2308, 2361), + Interval::new(2365, 2365), + Interval::new(2384, 2384), + Interval::new(2392, 2401), + Interval::new(2417, 2432), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2493, 2493), + Interval::new(2510, 2510), + Interval::new(2524, 2525), + Interval::new(2527, 2529), + Interval::new(2544, 2545), + Interval::new(2556, 2556), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2674, 2676), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2749, 2749), + Interval::new(2768, 2768), + Interval::new(2784, 2785), + Interval::new(2809, 2809), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2877, 2877), + Interval::new(2908, 2909), + Interval::new(2911, 2913), + Interval::new(2929, 2929), + Interval::new(2947, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3024, 3024), + Interval::new(3077, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3133, 3133), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3169), + Interval::new(3200, 3200), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3261, 3261), + Interval::new(3292, 3294), + Interval::new(3296, 3297), + Interval::new(3313, 3314), + Interval::new(3332, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3386), + Interval::new(3389, 3389), + Interval::new(3406, 3406), + Interval::new(3412, 3414), + Interval::new(3423, 3425), + Interval::new(3450, 3455), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3585, 3632), + Interval::new(3634, 3635), + Interval::new(3648, 3654), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3760), + Interval::new(3762, 3763), + Interval::new(3773, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3904, 3911), + Interval::new(3913, 3948), + Interval::new(3976, 3980), + Interval::new(4096, 4138), + Interval::new(4159, 4159), + Interval::new(4176, 4181), + Interval::new(4186, 4189), + Interval::new(4193, 4193), + Interval::new(4197, 4198), + Interval::new(4206, 4208), + Interval::new(4213, 4225), + Interval::new(4238, 4238), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4992, 5007), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5870, 5880), + Interval::new(5888, 5905), + Interval::new(5919, 5937), + Interval::new(5952, 5969), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6016, 6067), + Interval::new(6103, 6103), + Interval::new(6108, 6108), + Interval::new(6176, 6264), + Interval::new(6272, 6312), + Interval::new(6314, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6480, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6656, 6678), + Interval::new(6688, 6740), + Interval::new(6823, 6823), + Interval::new(6917, 6963), + Interval::new(6981, 6988), + Interval::new(7043, 7072), + Interval::new(7086, 7087), + Interval::new(7098, 7141), + Interval::new(7168, 7203), + Interval::new(7245, 7247), + Interval::new(7258, 7293), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7414), + Interval::new(7418, 7418), + Interval::new(7424, 7615), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8472, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(11264, 11492), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11631), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(12293, 12295), + Interval::new(12321, 12329), + Interval::new(12337, 12341), + Interval::new(12344, 12348), + Interval::new(12353, 12438), + Interval::new(12443, 12447), + Interval::new(12449, 12538), + Interval::new(12540, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 42124), + Interval::new(42192, 42237), + Interval::new(42240, 42508), + Interval::new(42512, 42527), + Interval::new(42538, 42539), + Interval::new(42560, 42606), + Interval::new(42623, 42653), + Interval::new(42656, 42735), + Interval::new(42775, 42783), + Interval::new(42786, 42888), + Interval::new(42891, 42972), + Interval::new(42993, 43009), + Interval::new(43011, 43013), + Interval::new(43015, 43018), + Interval::new(43020, 43042), + Interval::new(43072, 43123), + Interval::new(43138, 43187), + Interval::new(43250, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43262), + Interval::new(43274, 43301), + Interval::new(43312, 43334), + Interval::new(43360, 43388), + Interval::new(43396, 43442), + Interval::new(43471, 43471), + Interval::new(43488, 43492), + Interval::new(43494, 43503), + Interval::new(43514, 43518), + Interval::new(43520, 43560), + Interval::new(43584, 43586), + Interval::new(43588, 43595), + Interval::new(43616, 43638), + Interval::new(43642, 43642), + Interval::new(43646, 43695), + Interval::new(43697, 43697), + Interval::new(43701, 43702), + Interval::new(43705, 43709), + Interval::new(43712, 43712), + Interval::new(43714, 43714), + Interval::new(43739, 43741), + Interval::new(43744, 43754), + Interval::new(43762, 43764), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 44002), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64285), + Interval::new(64287, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65019), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(65382, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65856, 65908), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66304, 66335), + Interval::new(66349, 66378), + Interval::new(66384, 66421), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66513, 66517), + Interval::new(66560, 66717), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68096), + Interval::new(68112, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68324), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68864, 68899), + Interval::new(68938, 68965), + Interval::new(68975, 68997), + Interval::new(69248, 69289), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69376, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69445), + Interval::new(69488, 69505), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69635, 69687), + Interval::new(69745, 69746), + Interval::new(69749, 69749), + Interval::new(69763, 69807), + Interval::new(69840, 69864), + Interval::new(69891, 69926), + Interval::new(69956, 69956), + Interval::new(69959, 69959), + Interval::new(69968, 70002), + Interval::new(70006, 70006), + Interval::new(70019, 70066), + Interval::new(70081, 70084), + Interval::new(70106, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70187), + Interval::new(70207, 70208), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70366), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70461, 70461), + Interval::new(70480, 70480), + Interval::new(70493, 70497), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70583), + Interval::new(70609, 70609), + Interval::new(70611, 70611), + Interval::new(70656, 70708), + Interval::new(70727, 70730), + Interval::new(70751, 70753), + Interval::new(70784, 70831), + Interval::new(70852, 70853), + Interval::new(70855, 70855), + Interval::new(71040, 71086), + Interval::new(71128, 71131), + Interval::new(71168, 71215), + Interval::new(71236, 71236), + Interval::new(71296, 71338), + Interval::new(71352, 71352), + Interval::new(71424, 71450), + Interval::new(71488, 71494), + Interval::new(71680, 71723), + Interval::new(71840, 71903), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71983), + Interval::new(71999, 71999), + Interval::new(72001, 72001), + Interval::new(72096, 72103), + Interval::new(72106, 72144), + Interval::new(72161, 72161), + Interval::new(72163, 72163), + Interval::new(72192, 72192), + Interval::new(72203, 72242), + Interval::new(72250, 72250), + Interval::new(72272, 72272), + Interval::new(72284, 72329), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72640, 72672), + Interval::new(72704, 72712), + Interval::new(72714, 72750), + Interval::new(72768, 72768), + Interval::new(72818, 72847), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73008), + Interval::new(73030, 73030), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73097), + Interval::new(73112, 73112), + Interval::new(73136, 73179), + Interval::new(73440, 73458), + Interval::new(73474, 73474), + Interval::new(73476, 73488), + Interval::new(73490, 73523), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74752, 74862), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78913, 78918), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90397), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92784, 92862), + Interval::new(92880, 92909), + Interval::new(92928, 92975), + Interval::new(92992, 92995), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93548), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94032, 94032), + Interval::new(94099, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94179), + Interval::new(94194, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122928, 122989), + Interval::new(123136, 123180), + Interval::new(123191, 123197), + Interval::new(123214, 123214), + Interval::new(123536, 123565), + Interval::new(123584, 123627), + Interval::new(124112, 124139), + Interval::new(124368, 124397), + Interval::new(124400, 124400), + Interval::new(124608, 124638), + Interval::new(124640, 124642), + Interval::new(124644, 124645), + Interval::new(124647, 124653), + Interval::new(124656, 124660), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125184, 125251), + Interval::new(125259, 125259), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'ID_Start' Unicode property. +pub(crate) fn id_start_ranges() -> &'static [Interval] { + &ID_START +} + +const MATH: [Interval; 141] = [ + Interval::new(43, 43), + Interval::new(60, 62), + Interval::new(94, 94), + Interval::new(124, 124), + Interval::new(126, 126), + Interval::new(172, 172), + Interval::new(177, 177), + Interval::new(215, 215), + Interval::new(247, 247), + Interval::new(976, 978), + Interval::new(981, 981), + Interval::new(1008, 1009), + Interval::new(1012, 1014), + Interval::new(1542, 1544), + Interval::new(8214, 8214), + Interval::new(8242, 8244), + Interval::new(8256, 8256), + Interval::new(8260, 8260), + Interval::new(8274, 8274), + Interval::new(8289, 8292), + Interval::new(8314, 8318), + Interval::new(8330, 8334), + Interval::new(8400, 8412), + Interval::new(8417, 8417), + Interval::new(8421, 8422), + Interval::new(8427, 8431), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8472, 8477), + Interval::new(8484, 8484), + Interval::new(8488, 8489), + Interval::new(8492, 8493), + Interval::new(8495, 8497), + Interval::new(8499, 8504), + Interval::new(8508, 8521), + Interval::new(8523, 8523), + Interval::new(8592, 8615), + Interval::new(8617, 8622), + Interval::new(8624, 8625), + Interval::new(8630, 8631), + Interval::new(8636, 8667), + Interval::new(8669, 8669), + Interval::new(8676, 8677), + Interval::new(8692, 8959), + Interval::new(8968, 8971), + Interval::new(8992, 8993), + Interval::new(9084, 9084), + Interval::new(9115, 9141), + Interval::new(9143, 9143), + Interval::new(9168, 9168), + Interval::new(9180, 9186), + Interval::new(9632, 9633), + Interval::new(9646, 9655), + Interval::new(9660, 9665), + Interval::new(9670, 9671), + Interval::new(9674, 9675), + Interval::new(9679, 9683), + Interval::new(9698, 9698), + Interval::new(9700, 9700), + Interval::new(9703, 9708), + Interval::new(9720, 9727), + Interval::new(9733, 9734), + Interval::new(9792, 9792), + Interval::new(9794, 9794), + Interval::new(9824, 9827), + Interval::new(9837, 9839), + Interval::new(10176, 10239), + Interval::new(10496, 11007), + Interval::new(11056, 11076), + Interval::new(11079, 11084), + Interval::new(64297, 64297), + Interval::new(65121, 65126), + Interval::new(65128, 65128), + Interval::new(65291, 65291), + Interval::new(65308, 65310), + Interval::new(65340, 65340), + Interval::new(65342, 65342), + Interval::new(65372, 65372), + Interval::new(65374, 65374), + Interval::new(65506, 65506), + Interval::new(65513, 65516), + Interval::new(69006, 69007), + Interval::new(118512, 118512), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120779), + Interval::new(120782, 120831), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(126704, 126705), + Interval::new(129232, 129240), +]; + +/// Return the code point ranges of the 'Math' Unicode property. +pub(crate) fn math_ranges() -> &'static [Interval] { + &MATH +} + +const XID_CONTINUE: [Interval; 806] = [ + Interval::new(48, 57), + Interval::new(65, 90), + Interval::new(95, 95), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(183, 183), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(768, 884), + Interval::new(886, 887), + Interval::new(891, 893), + Interval::new(895, 895), + Interval::new(902, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1155, 1159), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1369), + Interval::new(1376, 1416), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1552, 1562), + Interval::new(1568, 1641), + Interval::new(1646, 1747), + Interval::new(1749, 1756), + Interval::new(1759, 1768), + Interval::new(1770, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1866), + Interval::new(1869, 1969), + Interval::new(1984, 2037), + Interval::new(2042, 2042), + Interval::new(2045, 2045), + Interval::new(2048, 2093), + Interval::new(2112, 2139), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2199, 2273), + Interval::new(2275, 2403), + Interval::new(2406, 2415), + Interval::new(2417, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2492, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2510), + Interval::new(2519, 2519), + Interval::new(2524, 2525), + Interval::new(2527, 2531), + Interval::new(2534, 2545), + Interval::new(2556, 2556), + Interval::new(2558, 2558), + Interval::new(2561, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2620, 2620), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2662, 2677), + Interval::new(2689, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2748, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2765), + Interval::new(2768, 2768), + Interval::new(2784, 2787), + Interval::new(2790, 2799), + Interval::new(2809, 2815), + Interval::new(2817, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2876, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2893), + Interval::new(2901, 2903), + Interval::new(2908, 2909), + Interval::new(2911, 2915), + Interval::new(2918, 2927), + Interval::new(2929, 2929), + Interval::new(2946, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3021), + Interval::new(3024, 3024), + Interval::new(3031, 3031), + Interval::new(3046, 3055), + Interval::new(3072, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3132, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3171), + Interval::new(3174, 3183), + Interval::new(3200, 3203), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3260, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3292, 3294), + Interval::new(3296, 3299), + Interval::new(3302, 3311), + Interval::new(3313, 3315), + Interval::new(3328, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3406), + Interval::new(3412, 3415), + Interval::new(3423, 3427), + Interval::new(3430, 3439), + Interval::new(3450, 3455), + Interval::new(3457, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3530, 3530), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3558, 3567), + Interval::new(3570, 3571), + Interval::new(3585, 3642), + Interval::new(3648, 3662), + Interval::new(3664, 3673), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3784, 3790), + Interval::new(3792, 3801), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3864, 3865), + Interval::new(3872, 3881), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3902, 3911), + Interval::new(3913, 3948), + Interval::new(3953, 3972), + Interval::new(3974, 3991), + Interval::new(3993, 4028), + Interval::new(4038, 4038), + Interval::new(4096, 4169), + Interval::new(4176, 4253), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4957, 4959), + Interval::new(4969, 4977), + Interval::new(4992, 5007), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5870, 5880), + Interval::new(5888, 5909), + Interval::new(5919, 5940), + Interval::new(5952, 5971), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6002, 6003), + Interval::new(6016, 6099), + Interval::new(6103, 6103), + Interval::new(6108, 6109), + Interval::new(6112, 6121), + Interval::new(6155, 6157), + Interval::new(6159, 6169), + Interval::new(6176, 6264), + Interval::new(6272, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6432, 6443), + Interval::new(6448, 6459), + Interval::new(6470, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6608, 6618), + Interval::new(6656, 6683), + Interval::new(6688, 6750), + Interval::new(6752, 6780), + Interval::new(6783, 6793), + Interval::new(6800, 6809), + Interval::new(6823, 6823), + Interval::new(6832, 6845), + Interval::new(6847, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6988), + Interval::new(6992, 7001), + Interval::new(7019, 7027), + Interval::new(7040, 7155), + Interval::new(7168, 7223), + Interval::new(7232, 7241), + Interval::new(7245, 7293), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7376, 7378), + Interval::new(7380, 7418), + Interval::new(7424, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8204, 8205), + Interval::new(8255, 8256), + Interval::new(8276, 8276), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8400, 8412), + Interval::new(8417, 8417), + Interval::new(8421, 8432), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8472, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(11264, 11492), + Interval::new(11499, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11631), + Interval::new(11647, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(11744, 11775), + Interval::new(12293, 12295), + Interval::new(12321, 12335), + Interval::new(12337, 12341), + Interval::new(12344, 12348), + Interval::new(12353, 12438), + Interval::new(12441, 12442), + Interval::new(12445, 12447), + Interval::new(12449, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 42124), + Interval::new(42192, 42237), + Interval::new(42240, 42508), + Interval::new(42512, 42539), + Interval::new(42560, 42607), + Interval::new(42612, 42621), + Interval::new(42623, 42737), + Interval::new(42775, 42783), + Interval::new(42786, 42888), + Interval::new(42891, 42972), + Interval::new(42993, 43047), + Interval::new(43052, 43052), + Interval::new(43072, 43123), + Interval::new(43136, 43205), + Interval::new(43216, 43225), + Interval::new(43232, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43309), + Interval::new(43312, 43347), + Interval::new(43360, 43388), + Interval::new(43392, 43456), + Interval::new(43471, 43481), + Interval::new(43488, 43518), + Interval::new(43520, 43574), + Interval::new(43584, 43597), + Interval::new(43600, 43609), + Interval::new(43616, 43638), + Interval::new(43642, 43714), + Interval::new(43739, 43741), + Interval::new(43744, 43759), + Interval::new(43762, 43766), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 44010), + Interval::new(44012, 44013), + Interval::new(44016, 44025), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64605), + Interval::new(64612, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65017), + Interval::new(65024, 65039), + Interval::new(65056, 65071), + Interval::new(65075, 65076), + Interval::new(65101, 65103), + Interval::new(65137, 65137), + Interval::new(65139, 65139), + Interval::new(65143, 65143), + Interval::new(65145, 65145), + Interval::new(65147, 65147), + Interval::new(65149, 65149), + Interval::new(65151, 65276), + Interval::new(65296, 65305), + Interval::new(65313, 65338), + Interval::new(65343, 65343), + Interval::new(65345, 65370), + Interval::new(65381, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65856, 65908), + Interval::new(66045, 66045), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66272, 66272), + Interval::new(66304, 66335), + Interval::new(66349, 66378), + Interval::new(66384, 66426), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66513, 66517), + Interval::new(66560, 66717), + Interval::new(66720, 66729), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68326), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68864, 68903), + Interval::new(68912, 68921), + Interval::new(68928, 68965), + Interval::new(68969, 68973), + Interval::new(68975, 68997), + Interval::new(69248, 69289), + Interval::new(69291, 69292), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69370, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69456), + Interval::new(69488, 69509), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69632, 69702), + Interval::new(69734, 69749), + Interval::new(69759, 69818), + Interval::new(69826, 69826), + Interval::new(69840, 69864), + Interval::new(69872, 69881), + Interval::new(69888, 69940), + Interval::new(69942, 69951), + Interval::new(69956, 69959), + Interval::new(69968, 70003), + Interval::new(70006, 70006), + Interval::new(70016, 70084), + Interval::new(70089, 70092), + Interval::new(70094, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70199), + Interval::new(70206, 70209), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70378), + Interval::new(70384, 70393), + Interval::new(70400, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70459, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70480, 70480), + Interval::new(70487, 70487), + Interval::new(70493, 70499), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70611), + Interval::new(70625, 70626), + Interval::new(70656, 70730), + Interval::new(70736, 70745), + Interval::new(70750, 70753), + Interval::new(70784, 70853), + Interval::new(70855, 70855), + Interval::new(70864, 70873), + Interval::new(71040, 71093), + Interval::new(71096, 71104), + Interval::new(71128, 71133), + Interval::new(71168, 71232), + Interval::new(71236, 71236), + Interval::new(71248, 71257), + Interval::new(71296, 71352), + Interval::new(71360, 71369), + Interval::new(71376, 71395), + Interval::new(71424, 71450), + Interval::new(71453, 71467), + Interval::new(71472, 71481), + Interval::new(71488, 71494), + Interval::new(71680, 71738), + Interval::new(71840, 71913), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71989), + Interval::new(71991, 71992), + Interval::new(71995, 72003), + Interval::new(72016, 72025), + Interval::new(72096, 72103), + Interval::new(72106, 72151), + Interval::new(72154, 72161), + Interval::new(72163, 72164), + Interval::new(72192, 72254), + Interval::new(72263, 72263), + Interval::new(72272, 72345), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72544, 72551), + Interval::new(72640, 72672), + Interval::new(72688, 72697), + Interval::new(72704, 72712), + Interval::new(72714, 72758), + Interval::new(72760, 72768), + Interval::new(72784, 72793), + Interval::new(72818, 72847), + Interval::new(72850, 72871), + Interval::new(72873, 72886), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73031), + Interval::new(73040, 73049), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73112), + Interval::new(73120, 73129), + Interval::new(73136, 73179), + Interval::new(73184, 73193), + Interval::new(73440, 73462), + Interval::new(73472, 73488), + Interval::new(73490, 73530), + Interval::new(73534, 73538), + Interval::new(73552, 73562), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74752, 74862), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78912, 78933), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90425), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92768, 92777), + Interval::new(92784, 92862), + Interval::new(92864, 92873), + Interval::new(92880, 92909), + Interval::new(92912, 92916), + Interval::new(92928, 92982), + Interval::new(92992, 92995), + Interval::new(93008, 93017), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93548), + Interval::new(93552, 93561), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94031, 94087), + Interval::new(94095, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94180), + Interval::new(94192, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113821, 113822), + Interval::new(118000, 118009), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119141, 119145), + Interval::new(119149, 119154), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(119362, 119364), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(120782, 120831), + Interval::new(121344, 121398), + Interval::new(121403, 121452), + Interval::new(121461, 121461), + Interval::new(121476, 121476), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(122928, 122989), + Interval::new(123023, 123023), + Interval::new(123136, 123180), + Interval::new(123184, 123197), + Interval::new(123200, 123209), + Interval::new(123214, 123214), + Interval::new(123536, 123566), + Interval::new(123584, 123641), + Interval::new(124112, 124153), + Interval::new(124368, 124410), + Interval::new(124608, 124638), + Interval::new(124640, 124661), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125136, 125142), + Interval::new(125184, 125259), + Interval::new(125264, 125273), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(130032, 130041), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'XID_Continue' Unicode property. +pub(crate) fn xid_continue_ranges() -> &'static [Interval] { + &XID_CONTINUE +} + +const XID_START: [Interval; 691] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(880, 884), + Interval::new(886, 887), + Interval::new(891, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1369), + Interval::new(1376, 1416), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1568, 1610), + Interval::new(1646, 1647), + Interval::new(1649, 1747), + Interval::new(1749, 1749), + Interval::new(1765, 1766), + Interval::new(1774, 1775), + Interval::new(1786, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1808), + Interval::new(1810, 1839), + Interval::new(1869, 1957), + Interval::new(1969, 1969), + Interval::new(1994, 2026), + Interval::new(2036, 2037), + Interval::new(2042, 2042), + Interval::new(2048, 2069), + Interval::new(2074, 2074), + Interval::new(2084, 2084), + Interval::new(2088, 2088), + Interval::new(2112, 2136), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2208, 2249), + Interval::new(2308, 2361), + Interval::new(2365, 2365), + Interval::new(2384, 2384), + Interval::new(2392, 2401), + Interval::new(2417, 2432), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2493, 2493), + Interval::new(2510, 2510), + Interval::new(2524, 2525), + Interval::new(2527, 2529), + Interval::new(2544, 2545), + Interval::new(2556, 2556), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2674, 2676), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2749, 2749), + Interval::new(2768, 2768), + Interval::new(2784, 2785), + Interval::new(2809, 2809), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2877, 2877), + Interval::new(2908, 2909), + Interval::new(2911, 2913), + Interval::new(2929, 2929), + Interval::new(2947, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3024, 3024), + Interval::new(3077, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3133, 3133), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3169), + Interval::new(3200, 3200), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3261, 3261), + Interval::new(3292, 3294), + Interval::new(3296, 3297), + Interval::new(3313, 3314), + Interval::new(3332, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3386), + Interval::new(3389, 3389), + Interval::new(3406, 3406), + Interval::new(3412, 3414), + Interval::new(3423, 3425), + Interval::new(3450, 3455), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3585, 3632), + Interval::new(3634, 3634), + Interval::new(3648, 3654), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3760), + Interval::new(3762, 3762), + Interval::new(3773, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3904, 3911), + Interval::new(3913, 3948), + Interval::new(3976, 3980), + Interval::new(4096, 4138), + Interval::new(4159, 4159), + Interval::new(4176, 4181), + Interval::new(4186, 4189), + Interval::new(4193, 4193), + Interval::new(4197, 4198), + Interval::new(4206, 4208), + Interval::new(4213, 4225), + Interval::new(4238, 4238), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4992, 5007), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5870, 5880), + Interval::new(5888, 5905), + Interval::new(5919, 5937), + Interval::new(5952, 5969), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6016, 6067), + Interval::new(6103, 6103), + Interval::new(6108, 6108), + Interval::new(6176, 6264), + Interval::new(6272, 6312), + Interval::new(6314, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6480, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6656, 6678), + Interval::new(6688, 6740), + Interval::new(6823, 6823), + Interval::new(6917, 6963), + Interval::new(6981, 6988), + Interval::new(7043, 7072), + Interval::new(7086, 7087), + Interval::new(7098, 7141), + Interval::new(7168, 7203), + Interval::new(7245, 7247), + Interval::new(7258, 7293), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7414), + Interval::new(7418, 7418), + Interval::new(7424, 7615), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8472, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(11264, 11492), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11631), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(12293, 12295), + Interval::new(12321, 12329), + Interval::new(12337, 12341), + Interval::new(12344, 12348), + Interval::new(12353, 12438), + Interval::new(12445, 12447), + Interval::new(12449, 12538), + Interval::new(12540, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 42124), + Interval::new(42192, 42237), + Interval::new(42240, 42508), + Interval::new(42512, 42527), + Interval::new(42538, 42539), + Interval::new(42560, 42606), + Interval::new(42623, 42653), + Interval::new(42656, 42735), + Interval::new(42775, 42783), + Interval::new(42786, 42888), + Interval::new(42891, 42972), + Interval::new(42993, 43009), + Interval::new(43011, 43013), + Interval::new(43015, 43018), + Interval::new(43020, 43042), + Interval::new(43072, 43123), + Interval::new(43138, 43187), + Interval::new(43250, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43262), + Interval::new(43274, 43301), + Interval::new(43312, 43334), + Interval::new(43360, 43388), + Interval::new(43396, 43442), + Interval::new(43471, 43471), + Interval::new(43488, 43492), + Interval::new(43494, 43503), + Interval::new(43514, 43518), + Interval::new(43520, 43560), + Interval::new(43584, 43586), + Interval::new(43588, 43595), + Interval::new(43616, 43638), + Interval::new(43642, 43642), + Interval::new(43646, 43695), + Interval::new(43697, 43697), + Interval::new(43701, 43702), + Interval::new(43705, 43709), + Interval::new(43712, 43712), + Interval::new(43714, 43714), + Interval::new(43739, 43741), + Interval::new(43744, 43754), + Interval::new(43762, 43764), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 44002), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64285), + Interval::new(64287, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64605), + Interval::new(64612, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65017), + Interval::new(65137, 65137), + Interval::new(65139, 65139), + Interval::new(65143, 65143), + Interval::new(65145, 65145), + Interval::new(65147, 65147), + Interval::new(65149, 65149), + Interval::new(65151, 65276), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(65382, 65437), + Interval::new(65440, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65856, 65908), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66304, 66335), + Interval::new(66349, 66378), + Interval::new(66384, 66421), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66513, 66517), + Interval::new(66560, 66717), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68096), + Interval::new(68112, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68324), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68864, 68899), + Interval::new(68938, 68965), + Interval::new(68975, 68997), + Interval::new(69248, 69289), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69376, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69445), + Interval::new(69488, 69505), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69635, 69687), + Interval::new(69745, 69746), + Interval::new(69749, 69749), + Interval::new(69763, 69807), + Interval::new(69840, 69864), + Interval::new(69891, 69926), + Interval::new(69956, 69956), + Interval::new(69959, 69959), + Interval::new(69968, 70002), + Interval::new(70006, 70006), + Interval::new(70019, 70066), + Interval::new(70081, 70084), + Interval::new(70106, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70187), + Interval::new(70207, 70208), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70366), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70461, 70461), + Interval::new(70480, 70480), + Interval::new(70493, 70497), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70583), + Interval::new(70609, 70609), + Interval::new(70611, 70611), + Interval::new(70656, 70708), + Interval::new(70727, 70730), + Interval::new(70751, 70753), + Interval::new(70784, 70831), + Interval::new(70852, 70853), + Interval::new(70855, 70855), + Interval::new(71040, 71086), + Interval::new(71128, 71131), + Interval::new(71168, 71215), + Interval::new(71236, 71236), + Interval::new(71296, 71338), + Interval::new(71352, 71352), + Interval::new(71424, 71450), + Interval::new(71488, 71494), + Interval::new(71680, 71723), + Interval::new(71840, 71903), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71983), + Interval::new(71999, 71999), + Interval::new(72001, 72001), + Interval::new(72096, 72103), + Interval::new(72106, 72144), + Interval::new(72161, 72161), + Interval::new(72163, 72163), + Interval::new(72192, 72192), + Interval::new(72203, 72242), + Interval::new(72250, 72250), + Interval::new(72272, 72272), + Interval::new(72284, 72329), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72640, 72672), + Interval::new(72704, 72712), + Interval::new(72714, 72750), + Interval::new(72768, 72768), + Interval::new(72818, 72847), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73008), + Interval::new(73030, 73030), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73097), + Interval::new(73112, 73112), + Interval::new(73136, 73179), + Interval::new(73440, 73458), + Interval::new(73474, 73474), + Interval::new(73476, 73488), + Interval::new(73490, 73523), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74752, 74862), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78913, 78918), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90397), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92784, 92862), + Interval::new(92880, 92909), + Interval::new(92928, 92975), + Interval::new(92992, 92995), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93548), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94032, 94032), + Interval::new(94099, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94179), + Interval::new(94194, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122928, 122989), + Interval::new(123136, 123180), + Interval::new(123191, 123197), + Interval::new(123214, 123214), + Interval::new(123536, 123565), + Interval::new(123584, 123627), + Interval::new(124112, 124139), + Interval::new(124368, 124397), + Interval::new(124400, 124400), + Interval::new(124608, 124638), + Interval::new(124640, 124642), + Interval::new(124644, 124645), + Interval::new(124647, 124653), + Interval::new(124656, 124660), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125184, 125251), + Interval::new(125259, 125259), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'XID_Start' Unicode property. +pub(crate) fn xid_start_ranges() -> &'static [Interval] { + &XID_START +} + +const ASCII_HEX_DIGIT: [Interval; 3] = [ + Interval::new(48, 57), + Interval::new(65, 70), + Interval::new(97, 102), +]; + +/// Return the code point ranges of the 'ASCII_Hex_Digit' Unicode property. +pub(crate) fn ascii_hex_digit_ranges() -> &'static [Interval] { + &ASCII_HEX_DIGIT +} + +const BIDI_CONTROL: [Interval; 4] = [ + Interval::new(1564, 1564), + Interval::new(8206, 8207), + Interval::new(8234, 8238), + Interval::new(8294, 8297), +]; + +/// Return the code point ranges of the 'Bidi_Control' Unicode property. +pub(crate) fn bidi_control_ranges() -> &'static [Interval] { + &BIDI_CONTROL +} + +const DASH: [Interval; 24] = [ + Interval::new(45, 45), + Interval::new(1418, 1418), + Interval::new(1470, 1470), + Interval::new(5120, 5120), + Interval::new(6150, 6150), + Interval::new(8208, 8213), + Interval::new(8275, 8275), + Interval::new(8315, 8315), + Interval::new(8331, 8331), + Interval::new(8722, 8722), + Interval::new(11799, 11799), + Interval::new(11802, 11802), + Interval::new(11834, 11835), + Interval::new(11840, 11840), + Interval::new(11869, 11869), + Interval::new(12316, 12316), + Interval::new(12336, 12336), + Interval::new(12448, 12448), + Interval::new(65073, 65074), + Interval::new(65112, 65112), + Interval::new(65123, 65123), + Interval::new(65293, 65293), + Interval::new(68974, 68974), + Interval::new(69293, 69293), +]; + +/// Return the code point ranges of the 'Dash' Unicode property. +pub(crate) fn dash_ranges() -> &'static [Interval] { + &DASH +} + +const DEPRECATED: [Interval; 8] = [ + Interval::new(329, 329), + Interval::new(1651, 1651), + Interval::new(3959, 3959), + Interval::new(3961, 3961), + Interval::new(6051, 6052), + Interval::new(8298, 8303), + Interval::new(9001, 9002), + Interval::new(917505, 917505), +]; + +/// Return the code point ranges of the 'Deprecated' Unicode property. +pub(crate) fn deprecated_ranges() -> &'static [Interval] { + &DEPRECATED +} + +const DIACRITIC: [Interval; 220] = [ + Interval::new(94, 94), + Interval::new(96, 96), + Interval::new(168, 168), + Interval::new(175, 175), + Interval::new(180, 180), + Interval::new(183, 184), + Interval::new(688, 846), + Interval::new(848, 855), + Interval::new(861, 866), + Interval::new(884, 885), + Interval::new(890, 890), + Interval::new(900, 901), + Interval::new(1155, 1159), + Interval::new(1369, 1369), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1611, 1618), + Interval::new(1623, 1624), + Interval::new(1759, 1760), + Interval::new(1765, 1766), + Interval::new(1770, 1772), + Interval::new(1840, 1866), + Interval::new(1958, 1968), + Interval::new(2027, 2037), + Interval::new(2072, 2073), + Interval::new(2200, 2207), + Interval::new(2249, 2258), + Interval::new(2275, 2302), + Interval::new(2364, 2364), + Interval::new(2381, 2381), + Interval::new(2385, 2388), + Interval::new(2417, 2417), + Interval::new(2492, 2492), + Interval::new(2509, 2509), + Interval::new(2620, 2620), + Interval::new(2637, 2637), + Interval::new(2748, 2748), + Interval::new(2765, 2765), + Interval::new(2813, 2815), + Interval::new(2876, 2876), + Interval::new(2893, 2893), + Interval::new(2901, 2901), + Interval::new(3021, 3021), + Interval::new(3132, 3132), + Interval::new(3149, 3149), + Interval::new(3260, 3260), + Interval::new(3277, 3277), + Interval::new(3387, 3388), + Interval::new(3405, 3405), + Interval::new(3530, 3530), + Interval::new(3642, 3642), + Interval::new(3655, 3660), + Interval::new(3662, 3662), + Interval::new(3770, 3770), + Interval::new(3784, 3788), + Interval::new(3864, 3865), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3902, 3903), + Interval::new(3970, 3972), + Interval::new(3974, 3975), + Interval::new(4038, 4038), + Interval::new(4151, 4151), + Interval::new(4153, 4154), + Interval::new(4195, 4196), + Interval::new(4201, 4205), + Interval::new(4231, 4237), + Interval::new(4239, 4239), + Interval::new(4250, 4251), + Interval::new(4957, 4959), + Interval::new(5908, 5909), + Interval::new(5940, 5940), + Interval::new(6089, 6099), + Interval::new(6109, 6109), + Interval::new(6457, 6459), + Interval::new(6752, 6752), + Interval::new(6773, 6780), + Interval::new(6783, 6783), + Interval::new(6832, 6846), + Interval::new(6849, 6859), + Interval::new(6863, 6877), + Interval::new(6880, 6891), + Interval::new(6964, 6964), + Interval::new(6980, 6980), + Interval::new(7019, 7027), + Interval::new(7082, 7083), + Interval::new(7142, 7142), + Interval::new(7154, 7155), + Interval::new(7222, 7223), + Interval::new(7288, 7293), + Interval::new(7376, 7400), + Interval::new(7405, 7405), + Interval::new(7412, 7412), + Interval::new(7415, 7417), + Interval::new(7468, 7530), + Interval::new(7579, 7614), + Interval::new(7620, 7631), + Interval::new(7669, 7679), + Interval::new(8125, 8125), + Interval::new(8127, 8129), + Interval::new(8141, 8143), + Interval::new(8157, 8159), + Interval::new(8173, 8175), + Interval::new(8189, 8190), + Interval::new(11503, 11505), + Interval::new(11823, 11823), + Interval::new(12330, 12335), + Interval::new(12441, 12444), + Interval::new(12540, 12540), + Interval::new(42607, 42607), + Interval::new(42620, 42621), + Interval::new(42623, 42623), + Interval::new(42652, 42653), + Interval::new(42736, 42737), + Interval::new(42752, 42785), + Interval::new(42888, 42890), + Interval::new(42993, 42993), + Interval::new(43000, 43001), + Interval::new(43014, 43014), + Interval::new(43052, 43052), + Interval::new(43204, 43204), + Interval::new(43232, 43249), + Interval::new(43307, 43310), + Interval::new(43347, 43347), + Interval::new(43443, 43443), + Interval::new(43456, 43456), + Interval::new(43493, 43493), + Interval::new(43643, 43645), + Interval::new(43711, 43714), + Interval::new(43766, 43766), + Interval::new(43867, 43871), + Interval::new(43881, 43883), + Interval::new(44012, 44013), + Interval::new(64286, 64286), + Interval::new(65056, 65071), + Interval::new(65342, 65342), + Interval::new(65344, 65344), + Interval::new(65392, 65392), + Interval::new(65438, 65439), + Interval::new(65507, 65507), + Interval::new(66272, 66272), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68325, 68326), + Interval::new(68898, 68903), + Interval::new(68942, 68942), + Interval::new(68969, 68973), + Interval::new(69370, 69370), + Interval::new(69373, 69375), + Interval::new(69446, 69456), + Interval::new(69506, 69509), + Interval::new(69702, 69702), + Interval::new(69744, 69744), + Interval::new(69817, 69818), + Interval::new(69939, 69940), + Interval::new(70003, 70003), + Interval::new(70080, 70080), + Interval::new(70090, 70092), + Interval::new(70197, 70198), + Interval::new(70377, 70378), + Interval::new(70459, 70460), + Interval::new(70477, 70477), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70606, 70608), + Interval::new(70610, 70611), + Interval::new(70625, 70626), + Interval::new(70722, 70722), + Interval::new(70726, 70726), + Interval::new(70850, 70851), + Interval::new(71103, 71104), + Interval::new(71231, 71231), + Interval::new(71350, 71351), + Interval::new(71467, 71467), + Interval::new(71737, 71738), + Interval::new(71997, 71998), + Interval::new(72003, 72003), + Interval::new(72160, 72160), + Interval::new(72244, 72244), + Interval::new(72263, 72263), + Interval::new(72345, 72345), + Interval::new(72767, 72767), + Interval::new(73026, 73026), + Interval::new(73028, 73029), + Interval::new(73111, 73111), + Interval::new(73177, 73177), + Interval::new(73537, 73538), + Interval::new(73562, 73562), + Interval::new(78919, 78933), + Interval::new(90415, 90415), + Interval::new(92912, 92916), + Interval::new(92976, 92982), + Interval::new(93547, 93548), + Interval::new(94095, 94111), + Interval::new(94192, 94193), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119143, 119145), + Interval::new(119149, 119154), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(122928, 122989), + Interval::new(123184, 123190), + Interval::new(123566, 123566), + Interval::new(123628, 123631), + Interval::new(124398, 124399), + Interval::new(125136, 125142), + Interval::new(125252, 125254), + Interval::new(125256, 125258), +]; + +/// Return the code point ranges of the 'Diacritic' Unicode property. +pub(crate) fn diacritic_ranges() -> &'static [Interval] { + &DIACRITIC +} + +const EXTENDER: [Interval; 43] = [ + Interval::new(183, 183), + Interval::new(720, 721), + Interval::new(1600, 1600), + Interval::new(2042, 2042), + Interval::new(2673, 2673), + Interval::new(2811, 2811), + Interval::new(2901, 2901), + Interval::new(3654, 3654), + Interval::new(3782, 3782), + Interval::new(6154, 6154), + Interval::new(6211, 6211), + Interval::new(6823, 6823), + Interval::new(7222, 7222), + Interval::new(7291, 7291), + Interval::new(12293, 12293), + Interval::new(12337, 12341), + Interval::new(12445, 12446), + Interval::new(12540, 12542), + Interval::new(40981, 40981), + Interval::new(42508, 42508), + Interval::new(43471, 43471), + Interval::new(43494, 43494), + Interval::new(43632, 43632), + Interval::new(43741, 43741), + Interval::new(43763, 43764), + Interval::new(65392, 65392), + Interval::new(67457, 67458), + Interval::new(68942, 68942), + Interval::new(68970, 68970), + Interval::new(68975, 68975), + Interval::new(70199, 70199), + Interval::new(70493, 70493), + Interval::new(70610, 70611), + Interval::new(71110, 71112), + Interval::new(72344, 72344), + Interval::new(73177, 73177), + Interval::new(92994, 92995), + Interval::new(94176, 94177), + Interval::new(94179, 94179), + Interval::new(94194, 94195), + Interval::new(123196, 123197), + Interval::new(124399, 124399), + Interval::new(125252, 125254), +]; + +/// Return the code point ranges of the 'Extender' Unicode property. +pub(crate) fn extender_ranges() -> &'static [Interval] { + &EXTENDER +} + +const HEX_DIGIT: [Interval; 6] = [ + Interval::new(48, 57), + Interval::new(65, 70), + Interval::new(97, 102), + Interval::new(65296, 65305), + Interval::new(65313, 65318), + Interval::new(65345, 65350), +]; + +/// Return the code point ranges of the 'Hex_Digit' Unicode property. +pub(crate) fn hex_digit_ranges() -> &'static [Interval] { + &HEX_DIGIT +} + +const IDS_BINARY_OPERATOR: [Interval; 3] = [ + Interval::new(12272, 12273), + Interval::new(12276, 12285), + Interval::new(12783, 12783), +]; + +/// Return the code point ranges of the 'IDS_Binary_Operator' Unicode property. +pub(crate) fn ids_binary_operator_ranges() -> &'static [Interval] { + &IDS_BINARY_OPERATOR +} + +const IDS_TRINARY_OPERATOR: [Interval; 1] = [Interval::new(12274, 12275)]; + +/// Return the code point ranges of the 'IDS_Trinary_Operator' Unicode property. +pub(crate) fn ids_trinary_operator_ranges() -> &'static [Interval] { + &IDS_TRINARY_OPERATOR +} + +const IDEOGRAPHIC: [Interval; 21] = [ + Interval::new(12294, 12295), + Interval::new(12321, 12329), + Interval::new(12344, 12346), + Interval::new(13312, 19903), + Interval::new(19968, 40959), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(94180, 94180), + Interval::new(94194, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110960, 111355), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'Ideographic' Unicode property. +pub(crate) fn ideographic_ranges() -> &'static [Interval] { + &IDEOGRAPHIC +} + +const JOIN_CONTROL: [Interval; 1] = [Interval::new(8204, 8205)]; + +/// Return the code point ranges of the 'Join_Control' Unicode property. +pub(crate) fn join_control_ranges() -> &'static [Interval] { + &JOIN_CONTROL +} + +const LOGICAL_ORDER_EXCEPTION: [Interval; 7] = [ + Interval::new(3648, 3652), + Interval::new(3776, 3780), + Interval::new(6581, 6583), + Interval::new(6586, 6586), + Interval::new(43701, 43702), + Interval::new(43705, 43705), + Interval::new(43707, 43708), +]; + +/// Return the code point ranges of the 'Logical_Order_Exception' Unicode property. +pub(crate) fn logical_order_exception_ranges() -> &'static [Interval] { + &LOGICAL_ORDER_EXCEPTION +} + +const LOWERCASE: [Interval; 677] = [ + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(186, 186), + Interval::new(223, 246), + Interval::new(248, 255), + Interval::new(257, 257), + Interval::new(259, 259), + Interval::new(261, 261), + Interval::new(263, 263), + Interval::new(265, 265), + Interval::new(267, 267), + Interval::new(269, 269), + Interval::new(271, 271), + Interval::new(273, 273), + Interval::new(275, 275), + Interval::new(277, 277), + Interval::new(279, 279), + Interval::new(281, 281), + Interval::new(283, 283), + Interval::new(285, 285), + Interval::new(287, 287), + Interval::new(289, 289), + Interval::new(291, 291), + Interval::new(293, 293), + Interval::new(295, 295), + Interval::new(297, 297), + Interval::new(299, 299), + Interval::new(301, 301), + Interval::new(303, 303), + Interval::new(305, 305), + Interval::new(307, 307), + Interval::new(309, 309), + Interval::new(311, 312), + Interval::new(314, 314), + Interval::new(316, 316), + Interval::new(318, 318), + Interval::new(320, 320), + Interval::new(322, 322), + Interval::new(324, 324), + Interval::new(326, 326), + Interval::new(328, 329), + Interval::new(331, 331), + Interval::new(333, 333), + Interval::new(335, 335), + Interval::new(337, 337), + Interval::new(339, 339), + Interval::new(341, 341), + Interval::new(343, 343), + Interval::new(345, 345), + Interval::new(347, 347), + Interval::new(349, 349), + Interval::new(351, 351), + Interval::new(353, 353), + Interval::new(355, 355), + Interval::new(357, 357), + Interval::new(359, 359), + Interval::new(361, 361), + Interval::new(363, 363), + Interval::new(365, 365), + Interval::new(367, 367), + Interval::new(369, 369), + Interval::new(371, 371), + Interval::new(373, 373), + Interval::new(375, 375), + Interval::new(378, 378), + Interval::new(380, 380), + Interval::new(382, 384), + Interval::new(387, 387), + Interval::new(389, 389), + Interval::new(392, 392), + Interval::new(396, 397), + Interval::new(402, 402), + Interval::new(405, 405), + Interval::new(409, 411), + Interval::new(414, 414), + Interval::new(417, 417), + Interval::new(419, 419), + Interval::new(421, 421), + Interval::new(424, 424), + Interval::new(426, 427), + Interval::new(429, 429), + Interval::new(432, 432), + Interval::new(436, 436), + Interval::new(438, 438), + Interval::new(441, 442), + Interval::new(445, 447), + Interval::new(454, 454), + Interval::new(457, 457), + Interval::new(460, 460), + Interval::new(462, 462), + Interval::new(464, 464), + Interval::new(466, 466), + Interval::new(468, 468), + Interval::new(470, 470), + Interval::new(472, 472), + Interval::new(474, 474), + Interval::new(476, 477), + Interval::new(479, 479), + Interval::new(481, 481), + Interval::new(483, 483), + Interval::new(485, 485), + Interval::new(487, 487), + Interval::new(489, 489), + Interval::new(491, 491), + Interval::new(493, 493), + Interval::new(495, 496), + Interval::new(499, 499), + Interval::new(501, 501), + Interval::new(505, 505), + Interval::new(507, 507), + Interval::new(509, 509), + Interval::new(511, 511), + Interval::new(513, 513), + Interval::new(515, 515), + Interval::new(517, 517), + Interval::new(519, 519), + Interval::new(521, 521), + Interval::new(523, 523), + Interval::new(525, 525), + Interval::new(527, 527), + Interval::new(529, 529), + Interval::new(531, 531), + Interval::new(533, 533), + Interval::new(535, 535), + Interval::new(537, 537), + Interval::new(539, 539), + Interval::new(541, 541), + Interval::new(543, 543), + Interval::new(545, 545), + Interval::new(547, 547), + Interval::new(549, 549), + Interval::new(551, 551), + Interval::new(553, 553), + Interval::new(555, 555), + Interval::new(557, 557), + Interval::new(559, 559), + Interval::new(561, 561), + Interval::new(563, 569), + Interval::new(572, 572), + Interval::new(575, 576), + Interval::new(578, 578), + Interval::new(583, 583), + Interval::new(585, 585), + Interval::new(587, 587), + Interval::new(589, 589), + Interval::new(591, 659), + Interval::new(662, 696), + Interval::new(704, 705), + Interval::new(736, 740), + Interval::new(837, 837), + Interval::new(881, 881), + Interval::new(883, 883), + Interval::new(887, 887), + Interval::new(890, 893), + Interval::new(912, 912), + Interval::new(940, 974), + Interval::new(976, 977), + Interval::new(981, 983), + Interval::new(985, 985), + Interval::new(987, 987), + Interval::new(989, 989), + Interval::new(991, 991), + Interval::new(993, 993), + Interval::new(995, 995), + Interval::new(997, 997), + Interval::new(999, 999), + Interval::new(1001, 1001), + Interval::new(1003, 1003), + Interval::new(1005, 1005), + Interval::new(1007, 1011), + Interval::new(1013, 1013), + Interval::new(1016, 1016), + Interval::new(1019, 1020), + Interval::new(1072, 1119), + Interval::new(1121, 1121), + Interval::new(1123, 1123), + Interval::new(1125, 1125), + Interval::new(1127, 1127), + Interval::new(1129, 1129), + Interval::new(1131, 1131), + Interval::new(1133, 1133), + Interval::new(1135, 1135), + Interval::new(1137, 1137), + Interval::new(1139, 1139), + Interval::new(1141, 1141), + Interval::new(1143, 1143), + Interval::new(1145, 1145), + Interval::new(1147, 1147), + Interval::new(1149, 1149), + Interval::new(1151, 1151), + Interval::new(1153, 1153), + Interval::new(1163, 1163), + Interval::new(1165, 1165), + Interval::new(1167, 1167), + Interval::new(1169, 1169), + Interval::new(1171, 1171), + Interval::new(1173, 1173), + Interval::new(1175, 1175), + Interval::new(1177, 1177), + Interval::new(1179, 1179), + Interval::new(1181, 1181), + Interval::new(1183, 1183), + Interval::new(1185, 1185), + Interval::new(1187, 1187), + Interval::new(1189, 1189), + Interval::new(1191, 1191), + Interval::new(1193, 1193), + Interval::new(1195, 1195), + Interval::new(1197, 1197), + Interval::new(1199, 1199), + Interval::new(1201, 1201), + Interval::new(1203, 1203), + Interval::new(1205, 1205), + Interval::new(1207, 1207), + Interval::new(1209, 1209), + Interval::new(1211, 1211), + Interval::new(1213, 1213), + Interval::new(1215, 1215), + Interval::new(1218, 1218), + Interval::new(1220, 1220), + Interval::new(1222, 1222), + Interval::new(1224, 1224), + Interval::new(1226, 1226), + Interval::new(1228, 1228), + Interval::new(1230, 1231), + Interval::new(1233, 1233), + Interval::new(1235, 1235), + Interval::new(1237, 1237), + Interval::new(1239, 1239), + Interval::new(1241, 1241), + Interval::new(1243, 1243), + Interval::new(1245, 1245), + Interval::new(1247, 1247), + Interval::new(1249, 1249), + Interval::new(1251, 1251), + Interval::new(1253, 1253), + Interval::new(1255, 1255), + Interval::new(1257, 1257), + Interval::new(1259, 1259), + Interval::new(1261, 1261), + Interval::new(1263, 1263), + Interval::new(1265, 1265), + Interval::new(1267, 1267), + Interval::new(1269, 1269), + Interval::new(1271, 1271), + Interval::new(1273, 1273), + Interval::new(1275, 1275), + Interval::new(1277, 1277), + Interval::new(1279, 1279), + Interval::new(1281, 1281), + Interval::new(1283, 1283), + Interval::new(1285, 1285), + Interval::new(1287, 1287), + Interval::new(1289, 1289), + Interval::new(1291, 1291), + Interval::new(1293, 1293), + Interval::new(1295, 1295), + Interval::new(1297, 1297), + Interval::new(1299, 1299), + Interval::new(1301, 1301), + Interval::new(1303, 1303), + Interval::new(1305, 1305), + Interval::new(1307, 1307), + Interval::new(1309, 1309), + Interval::new(1311, 1311), + Interval::new(1313, 1313), + Interval::new(1315, 1315), + Interval::new(1317, 1317), + Interval::new(1319, 1319), + Interval::new(1321, 1321), + Interval::new(1323, 1323), + Interval::new(1325, 1325), + Interval::new(1327, 1327), + Interval::new(1376, 1416), + Interval::new(4304, 4346), + Interval::new(4348, 4351), + Interval::new(5112, 5117), + Interval::new(7296, 7304), + Interval::new(7306, 7306), + Interval::new(7424, 7615), + Interval::new(7681, 7681), + Interval::new(7683, 7683), + Interval::new(7685, 7685), + Interval::new(7687, 7687), + Interval::new(7689, 7689), + Interval::new(7691, 7691), + Interval::new(7693, 7693), + Interval::new(7695, 7695), + Interval::new(7697, 7697), + Interval::new(7699, 7699), + Interval::new(7701, 7701), + Interval::new(7703, 7703), + Interval::new(7705, 7705), + Interval::new(7707, 7707), + Interval::new(7709, 7709), + Interval::new(7711, 7711), + Interval::new(7713, 7713), + Interval::new(7715, 7715), + Interval::new(7717, 7717), + Interval::new(7719, 7719), + Interval::new(7721, 7721), + Interval::new(7723, 7723), + Interval::new(7725, 7725), + Interval::new(7727, 7727), + Interval::new(7729, 7729), + Interval::new(7731, 7731), + Interval::new(7733, 7733), + Interval::new(7735, 7735), + Interval::new(7737, 7737), + Interval::new(7739, 7739), + Interval::new(7741, 7741), + Interval::new(7743, 7743), + Interval::new(7745, 7745), + Interval::new(7747, 7747), + Interval::new(7749, 7749), + Interval::new(7751, 7751), + Interval::new(7753, 7753), + Interval::new(7755, 7755), + Interval::new(7757, 7757), + Interval::new(7759, 7759), + Interval::new(7761, 7761), + Interval::new(7763, 7763), + Interval::new(7765, 7765), + Interval::new(7767, 7767), + Interval::new(7769, 7769), + Interval::new(7771, 7771), + Interval::new(7773, 7773), + Interval::new(7775, 7775), + Interval::new(7777, 7777), + Interval::new(7779, 7779), + Interval::new(7781, 7781), + Interval::new(7783, 7783), + Interval::new(7785, 7785), + Interval::new(7787, 7787), + Interval::new(7789, 7789), + Interval::new(7791, 7791), + Interval::new(7793, 7793), + Interval::new(7795, 7795), + Interval::new(7797, 7797), + Interval::new(7799, 7799), + Interval::new(7801, 7801), + Interval::new(7803, 7803), + Interval::new(7805, 7805), + Interval::new(7807, 7807), + Interval::new(7809, 7809), + Interval::new(7811, 7811), + Interval::new(7813, 7813), + Interval::new(7815, 7815), + Interval::new(7817, 7817), + Interval::new(7819, 7819), + Interval::new(7821, 7821), + Interval::new(7823, 7823), + Interval::new(7825, 7825), + Interval::new(7827, 7827), + Interval::new(7829, 7837), + Interval::new(7839, 7839), + Interval::new(7841, 7841), + Interval::new(7843, 7843), + Interval::new(7845, 7845), + Interval::new(7847, 7847), + Interval::new(7849, 7849), + Interval::new(7851, 7851), + Interval::new(7853, 7853), + Interval::new(7855, 7855), + Interval::new(7857, 7857), + Interval::new(7859, 7859), + Interval::new(7861, 7861), + Interval::new(7863, 7863), + Interval::new(7865, 7865), + Interval::new(7867, 7867), + Interval::new(7869, 7869), + Interval::new(7871, 7871), + Interval::new(7873, 7873), + Interval::new(7875, 7875), + Interval::new(7877, 7877), + Interval::new(7879, 7879), + Interval::new(7881, 7881), + Interval::new(7883, 7883), + Interval::new(7885, 7885), + Interval::new(7887, 7887), + Interval::new(7889, 7889), + Interval::new(7891, 7891), + Interval::new(7893, 7893), + Interval::new(7895, 7895), + Interval::new(7897, 7897), + Interval::new(7899, 7899), + Interval::new(7901, 7901), + Interval::new(7903, 7903), + Interval::new(7905, 7905), + Interval::new(7907, 7907), + Interval::new(7909, 7909), + Interval::new(7911, 7911), + Interval::new(7913, 7913), + Interval::new(7915, 7915), + Interval::new(7917, 7917), + Interval::new(7919, 7919), + Interval::new(7921, 7921), + Interval::new(7923, 7923), + Interval::new(7925, 7925), + Interval::new(7927, 7927), + Interval::new(7929, 7929), + Interval::new(7931, 7931), + Interval::new(7933, 7933), + Interval::new(7935, 7943), + Interval::new(7952, 7957), + Interval::new(7968, 7975), + Interval::new(7984, 7991), + Interval::new(8000, 8005), + Interval::new(8016, 8023), + Interval::new(8032, 8039), + Interval::new(8048, 8061), + Interval::new(8064, 8071), + Interval::new(8080, 8087), + Interval::new(8096, 8103), + Interval::new(8112, 8116), + Interval::new(8118, 8119), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8135), + Interval::new(8144, 8147), + Interval::new(8150, 8151), + Interval::new(8160, 8167), + Interval::new(8178, 8180), + Interval::new(8182, 8183), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8458, 8458), + Interval::new(8462, 8463), + Interval::new(8467, 8467), + Interval::new(8495, 8495), + Interval::new(8500, 8500), + Interval::new(8505, 8505), + Interval::new(8508, 8509), + Interval::new(8518, 8521), + Interval::new(8526, 8526), + Interval::new(8560, 8575), + Interval::new(8580, 8580), + Interval::new(9424, 9449), + Interval::new(11312, 11359), + Interval::new(11361, 11361), + Interval::new(11365, 11366), + Interval::new(11368, 11368), + Interval::new(11370, 11370), + Interval::new(11372, 11372), + Interval::new(11377, 11377), + Interval::new(11379, 11380), + Interval::new(11382, 11389), + Interval::new(11393, 11393), + Interval::new(11395, 11395), + Interval::new(11397, 11397), + Interval::new(11399, 11399), + Interval::new(11401, 11401), + Interval::new(11403, 11403), + Interval::new(11405, 11405), + Interval::new(11407, 11407), + Interval::new(11409, 11409), + Interval::new(11411, 11411), + Interval::new(11413, 11413), + Interval::new(11415, 11415), + Interval::new(11417, 11417), + Interval::new(11419, 11419), + Interval::new(11421, 11421), + Interval::new(11423, 11423), + Interval::new(11425, 11425), + Interval::new(11427, 11427), + Interval::new(11429, 11429), + Interval::new(11431, 11431), + Interval::new(11433, 11433), + Interval::new(11435, 11435), + Interval::new(11437, 11437), + Interval::new(11439, 11439), + Interval::new(11441, 11441), + Interval::new(11443, 11443), + Interval::new(11445, 11445), + Interval::new(11447, 11447), + Interval::new(11449, 11449), + Interval::new(11451, 11451), + Interval::new(11453, 11453), + Interval::new(11455, 11455), + Interval::new(11457, 11457), + Interval::new(11459, 11459), + Interval::new(11461, 11461), + Interval::new(11463, 11463), + Interval::new(11465, 11465), + Interval::new(11467, 11467), + Interval::new(11469, 11469), + Interval::new(11471, 11471), + Interval::new(11473, 11473), + Interval::new(11475, 11475), + Interval::new(11477, 11477), + Interval::new(11479, 11479), + Interval::new(11481, 11481), + Interval::new(11483, 11483), + Interval::new(11485, 11485), + Interval::new(11487, 11487), + Interval::new(11489, 11489), + Interval::new(11491, 11492), + Interval::new(11500, 11500), + Interval::new(11502, 11502), + Interval::new(11507, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42561, 42561), + Interval::new(42563, 42563), + Interval::new(42565, 42565), + Interval::new(42567, 42567), + Interval::new(42569, 42569), + Interval::new(42571, 42571), + Interval::new(42573, 42573), + Interval::new(42575, 42575), + Interval::new(42577, 42577), + Interval::new(42579, 42579), + Interval::new(42581, 42581), + Interval::new(42583, 42583), + Interval::new(42585, 42585), + Interval::new(42587, 42587), + Interval::new(42589, 42589), + Interval::new(42591, 42591), + Interval::new(42593, 42593), + Interval::new(42595, 42595), + Interval::new(42597, 42597), + Interval::new(42599, 42599), + Interval::new(42601, 42601), + Interval::new(42603, 42603), + Interval::new(42605, 42605), + Interval::new(42625, 42625), + Interval::new(42627, 42627), + Interval::new(42629, 42629), + Interval::new(42631, 42631), + Interval::new(42633, 42633), + Interval::new(42635, 42635), + Interval::new(42637, 42637), + Interval::new(42639, 42639), + Interval::new(42641, 42641), + Interval::new(42643, 42643), + Interval::new(42645, 42645), + Interval::new(42647, 42647), + Interval::new(42649, 42649), + Interval::new(42651, 42653), + Interval::new(42787, 42787), + Interval::new(42789, 42789), + Interval::new(42791, 42791), + Interval::new(42793, 42793), + Interval::new(42795, 42795), + Interval::new(42797, 42797), + Interval::new(42799, 42801), + Interval::new(42803, 42803), + Interval::new(42805, 42805), + Interval::new(42807, 42807), + Interval::new(42809, 42809), + Interval::new(42811, 42811), + Interval::new(42813, 42813), + Interval::new(42815, 42815), + Interval::new(42817, 42817), + Interval::new(42819, 42819), + Interval::new(42821, 42821), + Interval::new(42823, 42823), + Interval::new(42825, 42825), + Interval::new(42827, 42827), + Interval::new(42829, 42829), + Interval::new(42831, 42831), + Interval::new(42833, 42833), + Interval::new(42835, 42835), + Interval::new(42837, 42837), + Interval::new(42839, 42839), + Interval::new(42841, 42841), + Interval::new(42843, 42843), + Interval::new(42845, 42845), + Interval::new(42847, 42847), + Interval::new(42849, 42849), + Interval::new(42851, 42851), + Interval::new(42853, 42853), + Interval::new(42855, 42855), + Interval::new(42857, 42857), + Interval::new(42859, 42859), + Interval::new(42861, 42861), + Interval::new(42863, 42872), + Interval::new(42874, 42874), + Interval::new(42876, 42876), + Interval::new(42879, 42879), + Interval::new(42881, 42881), + Interval::new(42883, 42883), + Interval::new(42885, 42885), + Interval::new(42887, 42887), + Interval::new(42892, 42892), + Interval::new(42894, 42894), + Interval::new(42897, 42897), + Interval::new(42899, 42901), + Interval::new(42903, 42903), + Interval::new(42905, 42905), + Interval::new(42907, 42907), + Interval::new(42909, 42909), + Interval::new(42911, 42911), + Interval::new(42913, 42913), + Interval::new(42915, 42915), + Interval::new(42917, 42917), + Interval::new(42919, 42919), + Interval::new(42921, 42921), + Interval::new(42927, 42927), + Interval::new(42933, 42933), + Interval::new(42935, 42935), + Interval::new(42937, 42937), + Interval::new(42939, 42939), + Interval::new(42941, 42941), + Interval::new(42943, 42943), + Interval::new(42945, 42945), + Interval::new(42947, 42947), + Interval::new(42952, 42952), + Interval::new(42954, 42954), + Interval::new(42957, 42957), + Interval::new(42959, 42959), + Interval::new(42961, 42961), + Interval::new(42963, 42963), + Interval::new(42965, 42965), + Interval::new(42967, 42967), + Interval::new(42969, 42969), + Interval::new(42971, 42971), + Interval::new(42993, 42996), + Interval::new(42998, 42998), + Interval::new(43000, 43002), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65345, 65370), + Interval::new(66600, 66639), + Interval::new(66776, 66811), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67456, 67456), + Interval::new(67459, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(68800, 68850), + Interval::new(68976, 68997), + Interval::new(71872, 71903), + Interval::new(93792, 93823), + Interval::new(93883, 93907), + Interval::new(119834, 119859), + Interval::new(119886, 119892), + Interval::new(119894, 119911), + Interval::new(119938, 119963), + Interval::new(119990, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120015), + Interval::new(120042, 120067), + Interval::new(120094, 120119), + Interval::new(120146, 120171), + Interval::new(120198, 120223), + Interval::new(120250, 120275), + Interval::new(120302, 120327), + Interval::new(120354, 120379), + Interval::new(120406, 120431), + Interval::new(120458, 120485), + Interval::new(120514, 120538), + Interval::new(120540, 120545), + Interval::new(120572, 120596), + Interval::new(120598, 120603), + Interval::new(120630, 120654), + Interval::new(120656, 120661), + Interval::new(120688, 120712), + Interval::new(120714, 120719), + Interval::new(120746, 120770), + Interval::new(120772, 120777), + Interval::new(120779, 120779), + Interval::new(122624, 122633), + Interval::new(122635, 122654), + Interval::new(122661, 122666), + Interval::new(122928, 122989), + Interval::new(125218, 125251), +]; + +/// Return the code point ranges of the 'Lowercase' Unicode property. +pub(crate) fn lowercase_ranges() -> &'static [Interval] { + &LOWERCASE +} + +const NONCHARACTER_CODE_POINT: [Interval; 18] = [ + Interval::new(64976, 65007), + Interval::new(65534, 65535), + Interval::new(131070, 131071), + Interval::new(196606, 196607), + Interval::new(262142, 262143), + Interval::new(327678, 327679), + Interval::new(393214, 393215), + Interval::new(458750, 458751), + Interval::new(524286, 524287), + Interval::new(589822, 589823), + Interval::new(655358, 655359), + Interval::new(720894, 720895), + Interval::new(786430, 786431), + Interval::new(851966, 851967), + Interval::new(917502, 917503), + Interval::new(983038, 983039), + Interval::new(1048574, 1048575), + Interval::new(1114110, 1114111), +]; + +/// Return the code point ranges of the 'Noncharacter_Code_Point' Unicode property. +pub(crate) fn noncharacter_code_point_ranges() -> &'static [Interval] { + &NONCHARACTER_CODE_POINT +} + +const PATTERN_SYNTAX: [Interval; 28] = [ + Interval::new(33, 47), + Interval::new(58, 64), + Interval::new(91, 94), + Interval::new(96, 96), + Interval::new(123, 126), + Interval::new(161, 167), + Interval::new(169, 169), + Interval::new(171, 172), + Interval::new(174, 174), + Interval::new(176, 177), + Interval::new(182, 182), + Interval::new(187, 187), + Interval::new(191, 191), + Interval::new(215, 215), + Interval::new(247, 247), + Interval::new(8208, 8231), + Interval::new(8240, 8254), + Interval::new(8257, 8275), + Interval::new(8277, 8286), + Interval::new(8592, 9311), + Interval::new(9472, 10101), + Interval::new(10132, 11263), + Interval::new(11776, 11903), + Interval::new(12289, 12291), + Interval::new(12296, 12320), + Interval::new(12336, 12336), + Interval::new(64830, 64831), + Interval::new(65093, 65094), +]; + +/// Return the code point ranges of the 'Pattern_Syntax' Unicode property. +pub(crate) fn pattern_syntax_ranges() -> &'static [Interval] { + &PATTERN_SYNTAX +} + +const PATTERN_WHITE_SPACE: [Interval; 5] = [ + Interval::new(9, 13), + Interval::new(32, 32), + Interval::new(133, 133), + Interval::new(8206, 8207), + Interval::new(8232, 8233), +]; + +/// Return the code point ranges of the 'Pattern_White_Space' Unicode property. +pub(crate) fn pattern_white_space_ranges() -> &'static [Interval] { + &PATTERN_WHITE_SPACE +} + +const QUOTATION_MARK: [Interval; 13] = [ + Interval::new(34, 34), + Interval::new(39, 39), + Interval::new(171, 171), + Interval::new(187, 187), + Interval::new(8216, 8223), + Interval::new(8249, 8250), + Interval::new(11842, 11842), + Interval::new(12300, 12303), + Interval::new(12317, 12319), + Interval::new(65089, 65092), + Interval::new(65282, 65282), + Interval::new(65287, 65287), + Interval::new(65378, 65379), +]; + +/// Return the code point ranges of the 'Quotation_Mark' Unicode property. +pub(crate) fn quotation_mark_ranges() -> &'static [Interval] { + "ATION_MARK +} + +const RADICAL: [Interval; 3] = [ + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), +]; + +/// Return the code point ranges of the 'Radical' Unicode property. +pub(crate) fn radical_ranges() -> &'static [Interval] { + &RADICAL +} + +const REGIONAL_INDICATOR: [Interval; 1] = [Interval::new(127462, 127487)]; + +/// Return the code point ranges of the 'Regional_Indicator' Unicode property. +pub(crate) fn regional_indicator_ranges() -> &'static [Interval] { + ®IONAL_INDICATOR +} + +const SENTENCE_TERMINAL: [Interval; 88] = [ + Interval::new(33, 33), + Interval::new(46, 46), + Interval::new(63, 63), + Interval::new(1417, 1417), + Interval::new(1565, 1567), + Interval::new(1748, 1748), + Interval::new(1792, 1794), + Interval::new(2041, 2041), + Interval::new(2103, 2103), + Interval::new(2105, 2105), + Interval::new(2109, 2110), + Interval::new(2404, 2405), + Interval::new(4170, 4171), + Interval::new(4962, 4962), + Interval::new(4967, 4968), + Interval::new(5742, 5742), + Interval::new(5941, 5942), + Interval::new(6100, 6101), + Interval::new(6147, 6147), + Interval::new(6153, 6153), + Interval::new(6468, 6469), + Interval::new(6824, 6827), + Interval::new(6990, 6991), + Interval::new(7002, 7003), + Interval::new(7006, 7007), + Interval::new(7037, 7039), + Interval::new(7227, 7228), + Interval::new(7294, 7295), + Interval::new(8228, 8228), + Interval::new(8252, 8253), + Interval::new(8263, 8265), + Interval::new(11513, 11515), + Interval::new(11822, 11822), + Interval::new(11836, 11836), + Interval::new(11859, 11860), + Interval::new(12290, 12290), + Interval::new(42239, 42239), + Interval::new(42510, 42511), + Interval::new(42739, 42739), + Interval::new(42743, 42743), + Interval::new(43126, 43127), + Interval::new(43214, 43215), + Interval::new(43311, 43311), + Interval::new(43464, 43465), + Interval::new(43613, 43615), + Interval::new(43760, 43761), + Interval::new(44011, 44011), + Interval::new(65042, 65042), + Interval::new(65045, 65046), + Interval::new(65106, 65106), + Interval::new(65110, 65111), + Interval::new(65281, 65281), + Interval::new(65294, 65294), + Interval::new(65311, 65311), + Interval::new(65377, 65377), + Interval::new(68182, 68183), + Interval::new(69461, 69465), + Interval::new(69510, 69513), + Interval::new(69703, 69704), + Interval::new(69822, 69825), + Interval::new(69953, 69955), + Interval::new(70085, 70086), + Interval::new(70093, 70093), + Interval::new(70110, 70111), + Interval::new(70200, 70201), + Interval::new(70203, 70204), + Interval::new(70313, 70313), + Interval::new(70612, 70613), + Interval::new(70731, 70732), + Interval::new(71106, 71107), + Interval::new(71113, 71127), + Interval::new(71233, 71234), + Interval::new(71484, 71486), + Interval::new(72004, 72004), + Interval::new(72006, 72006), + Interval::new(72258, 72259), + Interval::new(72347, 72348), + Interval::new(72769, 72770), + Interval::new(73463, 73464), + Interval::new(73539, 73540), + Interval::new(92782, 92783), + Interval::new(92917, 92917), + Interval::new(92983, 92984), + Interval::new(92996, 92996), + Interval::new(93550, 93551), + Interval::new(93848, 93848), + Interval::new(113823, 113823), + Interval::new(121480, 121480), +]; + +/// Return the code point ranges of the 'Sentence_Terminal' Unicode property. +pub(crate) fn sentence_terminal_ranges() -> &'static [Interval] { + &SENTENCE_TERMINAL +} + +const SOFT_DOTTED: [Interval; 34] = [ + Interval::new(105, 106), + Interval::new(303, 303), + Interval::new(585, 585), + Interval::new(616, 616), + Interval::new(669, 669), + Interval::new(690, 690), + Interval::new(1011, 1011), + Interval::new(1110, 1110), + Interval::new(1112, 1112), + Interval::new(7522, 7522), + Interval::new(7574, 7574), + Interval::new(7588, 7588), + Interval::new(7592, 7592), + Interval::new(7725, 7725), + Interval::new(7883, 7883), + Interval::new(8305, 8305), + Interval::new(8520, 8521), + Interval::new(11388, 11388), + Interval::new(119842, 119843), + Interval::new(119894, 119895), + Interval::new(119946, 119947), + Interval::new(119998, 119999), + Interval::new(120050, 120051), + Interval::new(120102, 120103), + Interval::new(120154, 120155), + Interval::new(120206, 120207), + Interval::new(120258, 120259), + Interval::new(120310, 120311), + Interval::new(120362, 120363), + Interval::new(120414, 120415), + Interval::new(120466, 120467), + Interval::new(122650, 122650), + Interval::new(122956, 122957), + Interval::new(122984, 122984), +]; + +/// Return the code point ranges of the 'Soft_Dotted' Unicode property. +pub(crate) fn soft_dotted_ranges() -> &'static [Interval] { + &SOFT_DOTTED +} + +const TERMINAL_PUNCTUATION: [Interval; 116] = [ + Interval::new(33, 33), + Interval::new(44, 44), + Interval::new(46, 46), + Interval::new(58, 59), + Interval::new(63, 63), + Interval::new(894, 894), + Interval::new(903, 903), + Interval::new(1417, 1417), + Interval::new(1475, 1475), + Interval::new(1548, 1548), + Interval::new(1563, 1563), + Interval::new(1565, 1567), + Interval::new(1748, 1748), + Interval::new(1792, 1802), + Interval::new(1804, 1804), + Interval::new(2040, 2041), + Interval::new(2096, 2101), + Interval::new(2103, 2110), + Interval::new(2142, 2142), + Interval::new(2404, 2405), + Interval::new(3674, 3675), + Interval::new(3848, 3848), + Interval::new(3853, 3858), + Interval::new(4170, 4171), + Interval::new(4961, 4968), + Interval::new(5742, 5742), + Interval::new(5867, 5869), + Interval::new(5941, 5942), + Interval::new(6100, 6102), + Interval::new(6106, 6106), + Interval::new(6146, 6149), + Interval::new(6152, 6153), + Interval::new(6468, 6469), + Interval::new(6824, 6827), + Interval::new(6990, 6991), + Interval::new(7002, 7003), + Interval::new(7005, 7007), + Interval::new(7037, 7039), + Interval::new(7227, 7231), + Interval::new(7294, 7295), + Interval::new(8228, 8228), + Interval::new(8252, 8253), + Interval::new(8263, 8265), + Interval::new(11513, 11515), + Interval::new(11822, 11822), + Interval::new(11836, 11836), + Interval::new(11841, 11841), + Interval::new(11852, 11852), + Interval::new(11854, 11855), + Interval::new(11859, 11860), + Interval::new(12289, 12290), + Interval::new(42238, 42239), + Interval::new(42509, 42511), + Interval::new(42739, 42743), + Interval::new(43126, 43127), + Interval::new(43214, 43215), + Interval::new(43311, 43311), + Interval::new(43463, 43465), + Interval::new(43613, 43615), + Interval::new(43743, 43743), + Interval::new(43760, 43761), + Interval::new(44011, 44011), + Interval::new(65042, 65042), + Interval::new(65045, 65046), + Interval::new(65104, 65106), + Interval::new(65108, 65111), + Interval::new(65281, 65281), + Interval::new(65292, 65292), + Interval::new(65294, 65294), + Interval::new(65306, 65307), + Interval::new(65311, 65311), + Interval::new(65377, 65377), + Interval::new(65380, 65380), + Interval::new(66463, 66463), + Interval::new(66512, 66512), + Interval::new(67671, 67671), + Interval::new(67871, 67871), + Interval::new(68182, 68183), + Interval::new(68336, 68341), + Interval::new(68410, 68415), + Interval::new(68505, 68508), + Interval::new(69461, 69465), + Interval::new(69510, 69513), + Interval::new(69703, 69709), + Interval::new(69822, 69825), + Interval::new(69953, 69955), + Interval::new(70085, 70086), + Interval::new(70093, 70093), + Interval::new(70110, 70111), + Interval::new(70200, 70204), + Interval::new(70313, 70313), + Interval::new(70612, 70613), + Interval::new(70731, 70733), + Interval::new(70746, 70747), + Interval::new(71106, 71109), + Interval::new(71113, 71127), + Interval::new(71233, 71234), + Interval::new(71484, 71486), + Interval::new(72004, 72004), + Interval::new(72006, 72006), + Interval::new(72258, 72259), + Interval::new(72347, 72348), + Interval::new(72353, 72354), + Interval::new(72769, 72771), + Interval::new(72817, 72817), + Interval::new(73463, 73464), + Interval::new(73539, 73540), + Interval::new(74864, 74868), + Interval::new(92782, 92783), + Interval::new(92917, 92917), + Interval::new(92983, 92985), + Interval::new(92996, 92996), + Interval::new(93550, 93551), + Interval::new(93847, 93848), + Interval::new(113823, 113823), + Interval::new(121479, 121482), +]; + +/// Return the code point ranges of the 'Terminal_Punctuation' Unicode property. +pub(crate) fn terminal_punctuation_ranges() -> &'static [Interval] { + &TERMINAL_PUNCTUATION +} + +const UNIFIED_IDEOGRAPH: [Interval; 16] = [ + Interval::new(13312, 19903), + Interval::new(19968, 40959), + Interval::new(64014, 64015), + Interval::new(64017, 64017), + Interval::new(64019, 64020), + Interval::new(64031, 64031), + Interval::new(64033, 64033), + Interval::new(64035, 64036), + Interval::new(64039, 64041), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'Unified_Ideograph' Unicode property. +pub(crate) fn unified_ideograph_ranges() -> &'static [Interval] { + &UNIFIED_IDEOGRAPH +} + +const UPPERCASE: [Interval; 660] = [ + Interval::new(65, 90), + Interval::new(192, 214), + Interval::new(216, 222), + Interval::new(256, 256), + Interval::new(258, 258), + Interval::new(260, 260), + Interval::new(262, 262), + Interval::new(264, 264), + Interval::new(266, 266), + Interval::new(268, 268), + Interval::new(270, 270), + Interval::new(272, 272), + Interval::new(274, 274), + Interval::new(276, 276), + Interval::new(278, 278), + Interval::new(280, 280), + Interval::new(282, 282), + Interval::new(284, 284), + Interval::new(286, 286), + Interval::new(288, 288), + Interval::new(290, 290), + Interval::new(292, 292), + Interval::new(294, 294), + Interval::new(296, 296), + Interval::new(298, 298), + Interval::new(300, 300), + Interval::new(302, 302), + Interval::new(304, 304), + Interval::new(306, 306), + Interval::new(308, 308), + Interval::new(310, 310), + Interval::new(313, 313), + Interval::new(315, 315), + Interval::new(317, 317), + Interval::new(319, 319), + Interval::new(321, 321), + Interval::new(323, 323), + Interval::new(325, 325), + Interval::new(327, 327), + Interval::new(330, 330), + Interval::new(332, 332), + Interval::new(334, 334), + Interval::new(336, 336), + Interval::new(338, 338), + Interval::new(340, 340), + Interval::new(342, 342), + Interval::new(344, 344), + Interval::new(346, 346), + Interval::new(348, 348), + Interval::new(350, 350), + Interval::new(352, 352), + Interval::new(354, 354), + Interval::new(356, 356), + Interval::new(358, 358), + Interval::new(360, 360), + Interval::new(362, 362), + Interval::new(364, 364), + Interval::new(366, 366), + Interval::new(368, 368), + Interval::new(370, 370), + Interval::new(372, 372), + Interval::new(374, 374), + Interval::new(376, 377), + Interval::new(379, 379), + Interval::new(381, 381), + Interval::new(385, 386), + Interval::new(388, 388), + Interval::new(390, 391), + Interval::new(393, 395), + Interval::new(398, 401), + Interval::new(403, 404), + Interval::new(406, 408), + Interval::new(412, 413), + Interval::new(415, 416), + Interval::new(418, 418), + Interval::new(420, 420), + Interval::new(422, 423), + Interval::new(425, 425), + Interval::new(428, 428), + Interval::new(430, 431), + Interval::new(433, 435), + Interval::new(437, 437), + Interval::new(439, 440), + Interval::new(444, 444), + Interval::new(452, 452), + Interval::new(455, 455), + Interval::new(458, 458), + Interval::new(461, 461), + Interval::new(463, 463), + Interval::new(465, 465), + Interval::new(467, 467), + Interval::new(469, 469), + Interval::new(471, 471), + Interval::new(473, 473), + Interval::new(475, 475), + Interval::new(478, 478), + Interval::new(480, 480), + Interval::new(482, 482), + Interval::new(484, 484), + Interval::new(486, 486), + Interval::new(488, 488), + Interval::new(490, 490), + Interval::new(492, 492), + Interval::new(494, 494), + Interval::new(497, 497), + Interval::new(500, 500), + Interval::new(502, 504), + Interval::new(506, 506), + Interval::new(508, 508), + Interval::new(510, 510), + Interval::new(512, 512), + Interval::new(514, 514), + Interval::new(516, 516), + Interval::new(518, 518), + Interval::new(520, 520), + Interval::new(522, 522), + Interval::new(524, 524), + Interval::new(526, 526), + Interval::new(528, 528), + Interval::new(530, 530), + Interval::new(532, 532), + Interval::new(534, 534), + Interval::new(536, 536), + Interval::new(538, 538), + Interval::new(540, 540), + Interval::new(542, 542), + Interval::new(544, 544), + Interval::new(546, 546), + Interval::new(548, 548), + Interval::new(550, 550), + Interval::new(552, 552), + Interval::new(554, 554), + Interval::new(556, 556), + Interval::new(558, 558), + Interval::new(560, 560), + Interval::new(562, 562), + Interval::new(570, 571), + Interval::new(573, 574), + Interval::new(577, 577), + Interval::new(579, 582), + Interval::new(584, 584), + Interval::new(586, 586), + Interval::new(588, 588), + Interval::new(590, 590), + Interval::new(880, 880), + Interval::new(882, 882), + Interval::new(886, 886), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 911), + Interval::new(913, 929), + Interval::new(931, 939), + Interval::new(975, 975), + Interval::new(978, 980), + Interval::new(984, 984), + Interval::new(986, 986), + Interval::new(988, 988), + Interval::new(990, 990), + Interval::new(992, 992), + Interval::new(994, 994), + Interval::new(996, 996), + Interval::new(998, 998), + Interval::new(1000, 1000), + Interval::new(1002, 1002), + Interval::new(1004, 1004), + Interval::new(1006, 1006), + Interval::new(1012, 1012), + Interval::new(1015, 1015), + Interval::new(1017, 1018), + Interval::new(1021, 1071), + Interval::new(1120, 1120), + Interval::new(1122, 1122), + Interval::new(1124, 1124), + Interval::new(1126, 1126), + Interval::new(1128, 1128), + Interval::new(1130, 1130), + Interval::new(1132, 1132), + Interval::new(1134, 1134), + Interval::new(1136, 1136), + Interval::new(1138, 1138), + Interval::new(1140, 1140), + Interval::new(1142, 1142), + Interval::new(1144, 1144), + Interval::new(1146, 1146), + Interval::new(1148, 1148), + Interval::new(1150, 1150), + Interval::new(1152, 1152), + Interval::new(1162, 1162), + Interval::new(1164, 1164), + Interval::new(1166, 1166), + Interval::new(1168, 1168), + Interval::new(1170, 1170), + Interval::new(1172, 1172), + Interval::new(1174, 1174), + Interval::new(1176, 1176), + Interval::new(1178, 1178), + Interval::new(1180, 1180), + Interval::new(1182, 1182), + Interval::new(1184, 1184), + Interval::new(1186, 1186), + Interval::new(1188, 1188), + Interval::new(1190, 1190), + Interval::new(1192, 1192), + Interval::new(1194, 1194), + Interval::new(1196, 1196), + Interval::new(1198, 1198), + Interval::new(1200, 1200), + Interval::new(1202, 1202), + Interval::new(1204, 1204), + Interval::new(1206, 1206), + Interval::new(1208, 1208), + Interval::new(1210, 1210), + Interval::new(1212, 1212), + Interval::new(1214, 1214), + Interval::new(1216, 1217), + Interval::new(1219, 1219), + Interval::new(1221, 1221), + Interval::new(1223, 1223), + Interval::new(1225, 1225), + Interval::new(1227, 1227), + Interval::new(1229, 1229), + Interval::new(1232, 1232), + Interval::new(1234, 1234), + Interval::new(1236, 1236), + Interval::new(1238, 1238), + Interval::new(1240, 1240), + Interval::new(1242, 1242), + Interval::new(1244, 1244), + Interval::new(1246, 1246), + Interval::new(1248, 1248), + Interval::new(1250, 1250), + Interval::new(1252, 1252), + Interval::new(1254, 1254), + Interval::new(1256, 1256), + Interval::new(1258, 1258), + Interval::new(1260, 1260), + Interval::new(1262, 1262), + Interval::new(1264, 1264), + Interval::new(1266, 1266), + Interval::new(1268, 1268), + Interval::new(1270, 1270), + Interval::new(1272, 1272), + Interval::new(1274, 1274), + Interval::new(1276, 1276), + Interval::new(1278, 1278), + Interval::new(1280, 1280), + Interval::new(1282, 1282), + Interval::new(1284, 1284), + Interval::new(1286, 1286), + Interval::new(1288, 1288), + Interval::new(1290, 1290), + Interval::new(1292, 1292), + Interval::new(1294, 1294), + Interval::new(1296, 1296), + Interval::new(1298, 1298), + Interval::new(1300, 1300), + Interval::new(1302, 1302), + Interval::new(1304, 1304), + Interval::new(1306, 1306), + Interval::new(1308, 1308), + Interval::new(1310, 1310), + Interval::new(1312, 1312), + Interval::new(1314, 1314), + Interval::new(1316, 1316), + Interval::new(1318, 1318), + Interval::new(1320, 1320), + Interval::new(1322, 1322), + Interval::new(1324, 1324), + Interval::new(1326, 1326), + Interval::new(1329, 1366), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(5024, 5109), + Interval::new(7305, 7305), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7680, 7680), + Interval::new(7682, 7682), + Interval::new(7684, 7684), + Interval::new(7686, 7686), + Interval::new(7688, 7688), + Interval::new(7690, 7690), + Interval::new(7692, 7692), + Interval::new(7694, 7694), + Interval::new(7696, 7696), + Interval::new(7698, 7698), + Interval::new(7700, 7700), + Interval::new(7702, 7702), + Interval::new(7704, 7704), + Interval::new(7706, 7706), + Interval::new(7708, 7708), + Interval::new(7710, 7710), + Interval::new(7712, 7712), + Interval::new(7714, 7714), + Interval::new(7716, 7716), + Interval::new(7718, 7718), + Interval::new(7720, 7720), + Interval::new(7722, 7722), + Interval::new(7724, 7724), + Interval::new(7726, 7726), + Interval::new(7728, 7728), + Interval::new(7730, 7730), + Interval::new(7732, 7732), + Interval::new(7734, 7734), + Interval::new(7736, 7736), + Interval::new(7738, 7738), + Interval::new(7740, 7740), + Interval::new(7742, 7742), + Interval::new(7744, 7744), + Interval::new(7746, 7746), + Interval::new(7748, 7748), + Interval::new(7750, 7750), + Interval::new(7752, 7752), + Interval::new(7754, 7754), + Interval::new(7756, 7756), + Interval::new(7758, 7758), + Interval::new(7760, 7760), + Interval::new(7762, 7762), + Interval::new(7764, 7764), + Interval::new(7766, 7766), + Interval::new(7768, 7768), + Interval::new(7770, 7770), + Interval::new(7772, 7772), + Interval::new(7774, 7774), + Interval::new(7776, 7776), + Interval::new(7778, 7778), + Interval::new(7780, 7780), + Interval::new(7782, 7782), + Interval::new(7784, 7784), + Interval::new(7786, 7786), + Interval::new(7788, 7788), + Interval::new(7790, 7790), + Interval::new(7792, 7792), + Interval::new(7794, 7794), + Interval::new(7796, 7796), + Interval::new(7798, 7798), + Interval::new(7800, 7800), + Interval::new(7802, 7802), + Interval::new(7804, 7804), + Interval::new(7806, 7806), + Interval::new(7808, 7808), + Interval::new(7810, 7810), + Interval::new(7812, 7812), + Interval::new(7814, 7814), + Interval::new(7816, 7816), + Interval::new(7818, 7818), + Interval::new(7820, 7820), + Interval::new(7822, 7822), + Interval::new(7824, 7824), + Interval::new(7826, 7826), + Interval::new(7828, 7828), + Interval::new(7838, 7838), + Interval::new(7840, 7840), + Interval::new(7842, 7842), + Interval::new(7844, 7844), + Interval::new(7846, 7846), + Interval::new(7848, 7848), + Interval::new(7850, 7850), + Interval::new(7852, 7852), + Interval::new(7854, 7854), + Interval::new(7856, 7856), + Interval::new(7858, 7858), + Interval::new(7860, 7860), + Interval::new(7862, 7862), + Interval::new(7864, 7864), + Interval::new(7866, 7866), + Interval::new(7868, 7868), + Interval::new(7870, 7870), + Interval::new(7872, 7872), + Interval::new(7874, 7874), + Interval::new(7876, 7876), + Interval::new(7878, 7878), + Interval::new(7880, 7880), + Interval::new(7882, 7882), + Interval::new(7884, 7884), + Interval::new(7886, 7886), + Interval::new(7888, 7888), + Interval::new(7890, 7890), + Interval::new(7892, 7892), + Interval::new(7894, 7894), + Interval::new(7896, 7896), + Interval::new(7898, 7898), + Interval::new(7900, 7900), + Interval::new(7902, 7902), + Interval::new(7904, 7904), + Interval::new(7906, 7906), + Interval::new(7908, 7908), + Interval::new(7910, 7910), + Interval::new(7912, 7912), + Interval::new(7914, 7914), + Interval::new(7916, 7916), + Interval::new(7918, 7918), + Interval::new(7920, 7920), + Interval::new(7922, 7922), + Interval::new(7924, 7924), + Interval::new(7926, 7926), + Interval::new(7928, 7928), + Interval::new(7930, 7930), + Interval::new(7932, 7932), + Interval::new(7934, 7934), + Interval::new(7944, 7951), + Interval::new(7960, 7965), + Interval::new(7976, 7983), + Interval::new(7992, 7999), + Interval::new(8008, 8013), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8031), + Interval::new(8040, 8047), + Interval::new(8120, 8123), + Interval::new(8136, 8139), + Interval::new(8152, 8155), + Interval::new(8168, 8172), + Interval::new(8184, 8187), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8459, 8461), + Interval::new(8464, 8466), + Interval::new(8469, 8469), + Interval::new(8473, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8496, 8499), + Interval::new(8510, 8511), + Interval::new(8517, 8517), + Interval::new(8544, 8559), + Interval::new(8579, 8579), + Interval::new(9398, 9423), + Interval::new(11264, 11311), + Interval::new(11360, 11360), + Interval::new(11362, 11364), + Interval::new(11367, 11367), + Interval::new(11369, 11369), + Interval::new(11371, 11371), + Interval::new(11373, 11376), + Interval::new(11378, 11378), + Interval::new(11381, 11381), + Interval::new(11390, 11392), + Interval::new(11394, 11394), + Interval::new(11396, 11396), + Interval::new(11398, 11398), + Interval::new(11400, 11400), + Interval::new(11402, 11402), + Interval::new(11404, 11404), + Interval::new(11406, 11406), + Interval::new(11408, 11408), + Interval::new(11410, 11410), + Interval::new(11412, 11412), + Interval::new(11414, 11414), + Interval::new(11416, 11416), + Interval::new(11418, 11418), + Interval::new(11420, 11420), + Interval::new(11422, 11422), + Interval::new(11424, 11424), + Interval::new(11426, 11426), + Interval::new(11428, 11428), + Interval::new(11430, 11430), + Interval::new(11432, 11432), + Interval::new(11434, 11434), + Interval::new(11436, 11436), + Interval::new(11438, 11438), + Interval::new(11440, 11440), + Interval::new(11442, 11442), + Interval::new(11444, 11444), + Interval::new(11446, 11446), + Interval::new(11448, 11448), + Interval::new(11450, 11450), + Interval::new(11452, 11452), + Interval::new(11454, 11454), + Interval::new(11456, 11456), + Interval::new(11458, 11458), + Interval::new(11460, 11460), + Interval::new(11462, 11462), + Interval::new(11464, 11464), + Interval::new(11466, 11466), + Interval::new(11468, 11468), + Interval::new(11470, 11470), + Interval::new(11472, 11472), + Interval::new(11474, 11474), + Interval::new(11476, 11476), + Interval::new(11478, 11478), + Interval::new(11480, 11480), + Interval::new(11482, 11482), + Interval::new(11484, 11484), + Interval::new(11486, 11486), + Interval::new(11488, 11488), + Interval::new(11490, 11490), + Interval::new(11499, 11499), + Interval::new(11501, 11501), + Interval::new(11506, 11506), + Interval::new(42560, 42560), + Interval::new(42562, 42562), + Interval::new(42564, 42564), + Interval::new(42566, 42566), + Interval::new(42568, 42568), + Interval::new(42570, 42570), + Interval::new(42572, 42572), + Interval::new(42574, 42574), + Interval::new(42576, 42576), + Interval::new(42578, 42578), + Interval::new(42580, 42580), + Interval::new(42582, 42582), + Interval::new(42584, 42584), + Interval::new(42586, 42586), + Interval::new(42588, 42588), + Interval::new(42590, 42590), + Interval::new(42592, 42592), + Interval::new(42594, 42594), + Interval::new(42596, 42596), + Interval::new(42598, 42598), + Interval::new(42600, 42600), + Interval::new(42602, 42602), + Interval::new(42604, 42604), + Interval::new(42624, 42624), + Interval::new(42626, 42626), + Interval::new(42628, 42628), + Interval::new(42630, 42630), + Interval::new(42632, 42632), + Interval::new(42634, 42634), + Interval::new(42636, 42636), + Interval::new(42638, 42638), + Interval::new(42640, 42640), + Interval::new(42642, 42642), + Interval::new(42644, 42644), + Interval::new(42646, 42646), + Interval::new(42648, 42648), + Interval::new(42650, 42650), + Interval::new(42786, 42786), + Interval::new(42788, 42788), + Interval::new(42790, 42790), + Interval::new(42792, 42792), + Interval::new(42794, 42794), + Interval::new(42796, 42796), + Interval::new(42798, 42798), + Interval::new(42802, 42802), + Interval::new(42804, 42804), + Interval::new(42806, 42806), + Interval::new(42808, 42808), + Interval::new(42810, 42810), + Interval::new(42812, 42812), + Interval::new(42814, 42814), + Interval::new(42816, 42816), + Interval::new(42818, 42818), + Interval::new(42820, 42820), + Interval::new(42822, 42822), + Interval::new(42824, 42824), + Interval::new(42826, 42826), + Interval::new(42828, 42828), + Interval::new(42830, 42830), + Interval::new(42832, 42832), + Interval::new(42834, 42834), + Interval::new(42836, 42836), + Interval::new(42838, 42838), + Interval::new(42840, 42840), + Interval::new(42842, 42842), + Interval::new(42844, 42844), + Interval::new(42846, 42846), + Interval::new(42848, 42848), + Interval::new(42850, 42850), + Interval::new(42852, 42852), + Interval::new(42854, 42854), + Interval::new(42856, 42856), + Interval::new(42858, 42858), + Interval::new(42860, 42860), + Interval::new(42862, 42862), + Interval::new(42873, 42873), + Interval::new(42875, 42875), + Interval::new(42877, 42878), + Interval::new(42880, 42880), + Interval::new(42882, 42882), + Interval::new(42884, 42884), + Interval::new(42886, 42886), + Interval::new(42891, 42891), + Interval::new(42893, 42893), + Interval::new(42896, 42896), + Interval::new(42898, 42898), + Interval::new(42902, 42902), + Interval::new(42904, 42904), + Interval::new(42906, 42906), + Interval::new(42908, 42908), + Interval::new(42910, 42910), + Interval::new(42912, 42912), + Interval::new(42914, 42914), + Interval::new(42916, 42916), + Interval::new(42918, 42918), + Interval::new(42920, 42920), + Interval::new(42922, 42926), + Interval::new(42928, 42932), + Interval::new(42934, 42934), + Interval::new(42936, 42936), + Interval::new(42938, 42938), + Interval::new(42940, 42940), + Interval::new(42942, 42942), + Interval::new(42944, 42944), + Interval::new(42946, 42946), + Interval::new(42948, 42951), + Interval::new(42953, 42953), + Interval::new(42955, 42956), + Interval::new(42958, 42958), + Interval::new(42960, 42960), + Interval::new(42962, 42962), + Interval::new(42964, 42964), + Interval::new(42966, 42966), + Interval::new(42968, 42968), + Interval::new(42970, 42970), + Interval::new(42972, 42972), + Interval::new(42997, 42997), + Interval::new(65313, 65338), + Interval::new(66560, 66599), + Interval::new(66736, 66771), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(68736, 68786), + Interval::new(68944, 68965), + Interval::new(71840, 71871), + Interval::new(93760, 93791), + Interval::new(93856, 93880), + Interval::new(119808, 119833), + Interval::new(119860, 119885), + Interval::new(119912, 119937), + Interval::new(119964, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119989), + Interval::new(120016, 120041), + Interval::new(120068, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120120, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120172, 120197), + Interval::new(120224, 120249), + Interval::new(120276, 120301), + Interval::new(120328, 120353), + Interval::new(120380, 120405), + Interval::new(120432, 120457), + Interval::new(120488, 120512), + Interval::new(120546, 120570), + Interval::new(120604, 120628), + Interval::new(120662, 120686), + Interval::new(120720, 120744), + Interval::new(120778, 120778), + Interval::new(125184, 125217), + Interval::new(127280, 127305), + Interval::new(127312, 127337), + Interval::new(127344, 127369), +]; + +/// Return the code point ranges of the 'Uppercase' Unicode property. +pub(crate) fn uppercase_ranges() -> &'static [Interval] { + &UPPERCASE +} + +const VARIATION_SELECTOR: [Interval; 4] = [ + Interval::new(6155, 6157), + Interval::new(6159, 6159), + Interval::new(65024, 65039), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'Variation_Selector' Unicode property. +pub(crate) fn variation_selector_ranges() -> &'static [Interval] { + &VARIATION_SELECTOR +} + +const WHITE_SPACE: [Interval; 10] = [ + Interval::new(9, 13), + Interval::new(32, 32), + Interval::new(133, 133), + Interval::new(160, 160), + Interval::new(5760, 5760), + Interval::new(8192, 8202), + Interval::new(8232, 8233), + Interval::new(8239, 8239), + Interval::new(8287, 8287), + Interval::new(12288, 12288), +]; + +/// Return the code point ranges of the 'White_Space' Unicode property. +pub(crate) fn white_space_ranges() -> &'static [Interval] { + &WHITE_SPACE +} + +const EMOJI: [Interval; 151] = [ + Interval::new(35, 35), + Interval::new(42, 42), + Interval::new(48, 57), + Interval::new(169, 169), + Interval::new(174, 174), + Interval::new(8252, 8252), + Interval::new(8265, 8265), + Interval::new(8482, 8482), + Interval::new(8505, 8505), + Interval::new(8596, 8601), + Interval::new(8617, 8618), + Interval::new(8986, 8987), + Interval::new(9000, 9000), + Interval::new(9167, 9167), + Interval::new(9193, 9203), + Interval::new(9208, 9210), + Interval::new(9410, 9410), + Interval::new(9642, 9643), + Interval::new(9654, 9654), + Interval::new(9664, 9664), + Interval::new(9723, 9726), + Interval::new(9728, 9732), + Interval::new(9742, 9742), + Interval::new(9745, 9745), + Interval::new(9748, 9749), + Interval::new(9752, 9752), + Interval::new(9757, 9757), + Interval::new(9760, 9760), + Interval::new(9762, 9763), + Interval::new(9766, 9766), + Interval::new(9770, 9770), + Interval::new(9774, 9775), + Interval::new(9784, 9786), + Interval::new(9792, 9792), + Interval::new(9794, 9794), + Interval::new(9800, 9811), + Interval::new(9823, 9824), + Interval::new(9827, 9827), + Interval::new(9829, 9830), + Interval::new(9832, 9832), + Interval::new(9851, 9851), + Interval::new(9854, 9855), + Interval::new(9874, 9879), + Interval::new(9881, 9881), + Interval::new(9883, 9884), + Interval::new(9888, 9889), + Interval::new(9895, 9895), + Interval::new(9898, 9899), + Interval::new(9904, 9905), + Interval::new(9917, 9918), + Interval::new(9924, 9925), + Interval::new(9928, 9928), + Interval::new(9934, 9935), + Interval::new(9937, 9937), + Interval::new(9939, 9940), + Interval::new(9961, 9962), + Interval::new(9968, 9973), + Interval::new(9975, 9978), + Interval::new(9981, 9981), + Interval::new(9986, 9986), + Interval::new(9989, 9989), + Interval::new(9992, 9997), + Interval::new(9999, 9999), + Interval::new(10002, 10002), + Interval::new(10004, 10004), + Interval::new(10006, 10006), + Interval::new(10013, 10013), + Interval::new(10017, 10017), + Interval::new(10024, 10024), + Interval::new(10035, 10036), + Interval::new(10052, 10052), + Interval::new(10055, 10055), + Interval::new(10060, 10060), + Interval::new(10062, 10062), + Interval::new(10067, 10069), + Interval::new(10071, 10071), + Interval::new(10083, 10084), + Interval::new(10133, 10135), + Interval::new(10145, 10145), + Interval::new(10160, 10160), + Interval::new(10175, 10175), + Interval::new(10548, 10549), + Interval::new(11013, 11015), + Interval::new(11035, 11036), + Interval::new(11088, 11088), + Interval::new(11093, 11093), + Interval::new(12336, 12336), + Interval::new(12349, 12349), + Interval::new(12951, 12951), + Interval::new(12953, 12953), + Interval::new(126980, 126980), + Interval::new(127183, 127183), + Interval::new(127344, 127345), + Interval::new(127358, 127359), + Interval::new(127374, 127374), + Interval::new(127377, 127386), + Interval::new(127462, 127487), + Interval::new(127489, 127490), + Interval::new(127514, 127514), + Interval::new(127535, 127535), + Interval::new(127538, 127546), + Interval::new(127568, 127569), + Interval::new(127744, 127777), + Interval::new(127780, 127891), + Interval::new(127894, 127895), + Interval::new(127897, 127899), + Interval::new(127902, 127984), + Interval::new(127987, 127989), + Interval::new(127991, 128253), + Interval::new(128255, 128317), + Interval::new(128329, 128334), + Interval::new(128336, 128359), + Interval::new(128367, 128368), + Interval::new(128371, 128378), + Interval::new(128391, 128391), + Interval::new(128394, 128397), + Interval::new(128400, 128400), + Interval::new(128405, 128406), + Interval::new(128420, 128421), + Interval::new(128424, 128424), + Interval::new(128433, 128434), + Interval::new(128444, 128444), + Interval::new(128450, 128452), + Interval::new(128465, 128467), + Interval::new(128476, 128478), + Interval::new(128481, 128481), + Interval::new(128483, 128483), + Interval::new(128488, 128488), + Interval::new(128495, 128495), + Interval::new(128499, 128499), + Interval::new(128506, 128591), + Interval::new(128640, 128709), + Interval::new(128715, 128722), + Interval::new(128725, 128728), + Interval::new(128732, 128741), + Interval::new(128745, 128745), + Interval::new(128747, 128748), + Interval::new(128752, 128752), + Interval::new(128755, 128764), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129292, 129338), + Interval::new(129340, 129349), + Interval::new(129351, 129535), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), +]; + +/// Return the code point ranges of the 'Emoji' Unicode property. +pub(crate) fn emoji_ranges() -> &'static [Interval] { + &EMOJI +} + +const EMOJI_COMPONENT: [Interval; 10] = [ + Interval::new(35, 35), + Interval::new(42, 42), + Interval::new(48, 57), + Interval::new(8205, 8205), + Interval::new(8419, 8419), + Interval::new(65039, 65039), + Interval::new(127462, 127487), + Interval::new(127995, 127999), + Interval::new(129456, 129459), + Interval::new(917536, 917631), +]; + +/// Return the code point ranges of the 'Emoji_Component' Unicode property. +pub(crate) fn emoji_component_ranges() -> &'static [Interval] { + &EMOJI_COMPONENT +} + +const EMOJI_MODIFIER: [Interval; 1] = [Interval::new(127995, 127999)]; + +/// Return the code point ranges of the 'Emoji_Modifier' Unicode property. +pub(crate) fn emoji_modifier_ranges() -> &'static [Interval] { + &EMOJI_MODIFIER +} + +const EMOJI_MODIFIER_BASE: [Interval; 40] = [ + Interval::new(9757, 9757), + Interval::new(9977, 9977), + Interval::new(9994, 9997), + Interval::new(127877, 127877), + Interval::new(127938, 127940), + Interval::new(127943, 127943), + Interval::new(127946, 127948), + Interval::new(128066, 128067), + Interval::new(128070, 128080), + Interval::new(128102, 128120), + Interval::new(128124, 128124), + Interval::new(128129, 128131), + Interval::new(128133, 128135), + Interval::new(128143, 128143), + Interval::new(128145, 128145), + Interval::new(128170, 128170), + Interval::new(128372, 128373), + Interval::new(128378, 128378), + Interval::new(128400, 128400), + Interval::new(128405, 128406), + Interval::new(128581, 128583), + Interval::new(128587, 128591), + Interval::new(128675, 128675), + Interval::new(128692, 128694), + Interval::new(128704, 128704), + Interval::new(128716, 128716), + Interval::new(129292, 129292), + Interval::new(129295, 129295), + Interval::new(129304, 129311), + Interval::new(129318, 129318), + Interval::new(129328, 129337), + Interval::new(129340, 129342), + Interval::new(129399, 129399), + Interval::new(129461, 129462), + Interval::new(129464, 129465), + Interval::new(129467, 129467), + Interval::new(129485, 129487), + Interval::new(129489, 129501), + Interval::new(129731, 129733), + Interval::new(129776, 129784), +]; + +/// Return the code point ranges of the 'Emoji_Modifier_Base' Unicode property. +pub(crate) fn emoji_modifier_base_ranges() -> &'static [Interval] { + &EMOJI_MODIFIER_BASE +} + +const EMOJI_PRESENTATION: [Interval; 81] = [ + Interval::new(8986, 8987), + Interval::new(9193, 9196), + Interval::new(9200, 9200), + Interval::new(9203, 9203), + Interval::new(9725, 9726), + Interval::new(9748, 9749), + Interval::new(9800, 9811), + Interval::new(9855, 9855), + Interval::new(9875, 9875), + Interval::new(9889, 9889), + Interval::new(9898, 9899), + Interval::new(9917, 9918), + Interval::new(9924, 9925), + Interval::new(9934, 9934), + Interval::new(9940, 9940), + Interval::new(9962, 9962), + Interval::new(9970, 9971), + Interval::new(9973, 9973), + Interval::new(9978, 9978), + Interval::new(9981, 9981), + Interval::new(9989, 9989), + Interval::new(9994, 9995), + Interval::new(10024, 10024), + Interval::new(10060, 10060), + Interval::new(10062, 10062), + Interval::new(10067, 10069), + Interval::new(10071, 10071), + Interval::new(10133, 10135), + Interval::new(10160, 10160), + Interval::new(10175, 10175), + Interval::new(11035, 11036), + Interval::new(11088, 11088), + Interval::new(11093, 11093), + Interval::new(126980, 126980), + Interval::new(127183, 127183), + Interval::new(127374, 127374), + Interval::new(127377, 127386), + Interval::new(127462, 127487), + Interval::new(127489, 127489), + Interval::new(127514, 127514), + Interval::new(127535, 127535), + Interval::new(127538, 127542), + Interval::new(127544, 127546), + Interval::new(127568, 127569), + Interval::new(127744, 127776), + Interval::new(127789, 127797), + Interval::new(127799, 127868), + Interval::new(127870, 127891), + Interval::new(127904, 127946), + Interval::new(127951, 127955), + Interval::new(127968, 127984), + Interval::new(127988, 127988), + Interval::new(127992, 128062), + Interval::new(128064, 128064), + Interval::new(128066, 128252), + Interval::new(128255, 128317), + Interval::new(128331, 128334), + Interval::new(128336, 128359), + Interval::new(128378, 128378), + Interval::new(128405, 128406), + Interval::new(128420, 128420), + Interval::new(128507, 128591), + Interval::new(128640, 128709), + Interval::new(128716, 128716), + Interval::new(128720, 128722), + Interval::new(128725, 128728), + Interval::new(128732, 128735), + Interval::new(128747, 128748), + Interval::new(128756, 128764), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129292, 129338), + Interval::new(129340, 129349), + Interval::new(129351, 129535), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), +]; + +/// Return the code point ranges of the 'Emoji_Presentation' Unicode property. +pub(crate) fn emoji_presentation_ranges() -> &'static [Interval] { + &EMOJI_PRESENTATION +} + +const EXTENDED_PICTOGRAPHIC: [Interval; 156] = [ + Interval::new(169, 169), + Interval::new(174, 174), + Interval::new(8252, 8252), + Interval::new(8265, 8265), + Interval::new(8482, 8482), + Interval::new(8505, 8505), + Interval::new(8596, 8601), + Interval::new(8617, 8618), + Interval::new(8986, 8987), + Interval::new(9000, 9000), + Interval::new(9167, 9167), + Interval::new(9193, 9203), + Interval::new(9208, 9210), + Interval::new(9410, 9410), + Interval::new(9642, 9643), + Interval::new(9654, 9654), + Interval::new(9664, 9664), + Interval::new(9723, 9726), + Interval::new(9728, 9732), + Interval::new(9742, 9742), + Interval::new(9745, 9745), + Interval::new(9748, 9749), + Interval::new(9752, 9752), + Interval::new(9757, 9757), + Interval::new(9760, 9760), + Interval::new(9762, 9763), + Interval::new(9766, 9766), + Interval::new(9770, 9770), + Interval::new(9774, 9775), + Interval::new(9784, 9786), + Interval::new(9792, 9792), + Interval::new(9794, 9794), + Interval::new(9800, 9811), + Interval::new(9823, 9824), + Interval::new(9827, 9827), + Interval::new(9829, 9830), + Interval::new(9832, 9832), + Interval::new(9851, 9851), + Interval::new(9854, 9855), + Interval::new(9874, 9879), + Interval::new(9881, 9881), + Interval::new(9883, 9884), + Interval::new(9888, 9889), + Interval::new(9895, 9895), + Interval::new(9898, 9899), + Interval::new(9904, 9905), + Interval::new(9917, 9918), + Interval::new(9924, 9925), + Interval::new(9928, 9928), + Interval::new(9934, 9935), + Interval::new(9937, 9937), + Interval::new(9939, 9940), + Interval::new(9961, 9962), + Interval::new(9968, 9973), + Interval::new(9975, 9978), + Interval::new(9981, 9981), + Interval::new(9986, 9986), + Interval::new(9989, 9989), + Interval::new(9992, 9997), + Interval::new(9999, 9999), + Interval::new(10002, 10002), + Interval::new(10004, 10004), + Interval::new(10006, 10006), + Interval::new(10013, 10013), + Interval::new(10017, 10017), + Interval::new(10024, 10024), + Interval::new(10035, 10036), + Interval::new(10052, 10052), + Interval::new(10055, 10055), + Interval::new(10060, 10060), + Interval::new(10062, 10062), + Interval::new(10067, 10069), + Interval::new(10071, 10071), + Interval::new(10083, 10084), + Interval::new(10133, 10135), + Interval::new(10145, 10145), + Interval::new(10160, 10160), + Interval::new(10175, 10175), + Interval::new(10548, 10549), + Interval::new(11013, 11015), + Interval::new(11035, 11036), + Interval::new(11088, 11088), + Interval::new(11093, 11093), + Interval::new(12336, 12336), + Interval::new(12349, 12349), + Interval::new(12951, 12951), + Interval::new(12953, 12953), + Interval::new(126980, 126980), + Interval::new(127020, 127023), + Interval::new(127124, 127135), + Interval::new(127151, 127152), + Interval::new(127168, 127168), + Interval::new(127183, 127184), + Interval::new(127222, 127231), + Interval::new(127344, 127345), + Interval::new(127358, 127359), + Interval::new(127374, 127374), + Interval::new(127377, 127386), + Interval::new(127406, 127461), + Interval::new(127489, 127503), + Interval::new(127514, 127514), + Interval::new(127535, 127535), + Interval::new(127538, 127546), + Interval::new(127548, 127551), + Interval::new(127561, 127583), + Interval::new(127590, 127777), + Interval::new(127780, 127891), + Interval::new(127894, 127895), + Interval::new(127897, 127899), + Interval::new(127902, 127984), + Interval::new(127987, 127989), + Interval::new(127991, 127994), + Interval::new(128000, 128253), + Interval::new(128255, 128317), + Interval::new(128329, 128334), + Interval::new(128336, 128359), + Interval::new(128367, 128368), + Interval::new(128371, 128378), + Interval::new(128391, 128391), + Interval::new(128394, 128397), + Interval::new(128400, 128400), + Interval::new(128405, 128406), + Interval::new(128420, 128421), + Interval::new(128424, 128424), + Interval::new(128433, 128434), + Interval::new(128444, 128444), + Interval::new(128450, 128452), + Interval::new(128465, 128467), + Interval::new(128476, 128478), + Interval::new(128481, 128481), + Interval::new(128483, 128483), + Interval::new(128488, 128488), + Interval::new(128495, 128495), + Interval::new(128499, 128499), + Interval::new(128506, 128591), + Interval::new(128640, 128709), + Interval::new(128715, 128722), + Interval::new(128725, 128741), + Interval::new(128745, 128745), + Interval::new(128747, 128752), + Interval::new(128755, 128767), + Interval::new(128986, 129023), + Interval::new(129036, 129039), + Interval::new(129096, 129103), + Interval::new(129114, 129119), + Interval::new(129160, 129167), + Interval::new(129198, 129199), + Interval::new(129212, 129215), + Interval::new(129218, 129231), + Interval::new(129241, 129279), + Interval::new(129292, 129338), + Interval::new(129340, 129349), + Interval::new(129351, 129535), + Interval::new(129624, 129631), + Interval::new(129646, 129791), + Interval::new(130048, 131069), +]; + +/// Return the code point ranges of the 'Extended_Pictographic' Unicode property. +pub(crate) fn extended_pictographic_ranges() -> &'static [Interval] { + &EXTENDED_PICTOGRAPHIC +} + +const CHANGES_WHEN_NFKC_CASEFOLDED: [Interval; 848] = [ + Interval::new(65, 90), + Interval::new(160, 160), + Interval::new(168, 168), + Interval::new(170, 170), + Interval::new(173, 173), + Interval::new(175, 175), + Interval::new(178, 181), + Interval::new(184, 186), + Interval::new(188, 190), + Interval::new(192, 214), + Interval::new(216, 223), + Interval::new(256, 256), + Interval::new(258, 258), + Interval::new(260, 260), + Interval::new(262, 262), + Interval::new(264, 264), + Interval::new(266, 266), + Interval::new(268, 268), + Interval::new(270, 270), + Interval::new(272, 272), + Interval::new(274, 274), + Interval::new(276, 276), + Interval::new(278, 278), + Interval::new(280, 280), + Interval::new(282, 282), + Interval::new(284, 284), + Interval::new(286, 286), + Interval::new(288, 288), + Interval::new(290, 290), + Interval::new(292, 292), + Interval::new(294, 294), + Interval::new(296, 296), + Interval::new(298, 298), + Interval::new(300, 300), + Interval::new(302, 302), + Interval::new(304, 304), + Interval::new(306, 308), + Interval::new(310, 310), + Interval::new(313, 313), + Interval::new(315, 315), + Interval::new(317, 317), + Interval::new(319, 321), + Interval::new(323, 323), + Interval::new(325, 325), + Interval::new(327, 327), + Interval::new(329, 330), + Interval::new(332, 332), + Interval::new(334, 334), + Interval::new(336, 336), + Interval::new(338, 338), + Interval::new(340, 340), + Interval::new(342, 342), + Interval::new(344, 344), + Interval::new(346, 346), + Interval::new(348, 348), + Interval::new(350, 350), + Interval::new(352, 352), + Interval::new(354, 354), + Interval::new(356, 356), + Interval::new(358, 358), + Interval::new(360, 360), + Interval::new(362, 362), + Interval::new(364, 364), + Interval::new(366, 366), + Interval::new(368, 368), + Interval::new(370, 370), + Interval::new(372, 372), + Interval::new(374, 374), + Interval::new(376, 377), + Interval::new(379, 379), + Interval::new(381, 381), + Interval::new(383, 383), + Interval::new(385, 386), + Interval::new(388, 388), + Interval::new(390, 391), + Interval::new(393, 395), + Interval::new(398, 401), + Interval::new(403, 404), + Interval::new(406, 408), + Interval::new(412, 413), + Interval::new(415, 416), + Interval::new(418, 418), + Interval::new(420, 420), + Interval::new(422, 423), + Interval::new(425, 425), + Interval::new(428, 428), + Interval::new(430, 431), + Interval::new(433, 435), + Interval::new(437, 437), + Interval::new(439, 440), + Interval::new(444, 444), + Interval::new(452, 461), + Interval::new(463, 463), + Interval::new(465, 465), + Interval::new(467, 467), + Interval::new(469, 469), + Interval::new(471, 471), + Interval::new(473, 473), + Interval::new(475, 475), + Interval::new(478, 478), + Interval::new(480, 480), + Interval::new(482, 482), + Interval::new(484, 484), + Interval::new(486, 486), + Interval::new(488, 488), + Interval::new(490, 490), + Interval::new(492, 492), + Interval::new(494, 494), + Interval::new(497, 500), + Interval::new(502, 504), + Interval::new(506, 506), + Interval::new(508, 508), + Interval::new(510, 510), + Interval::new(512, 512), + Interval::new(514, 514), + Interval::new(516, 516), + Interval::new(518, 518), + Interval::new(520, 520), + Interval::new(522, 522), + Interval::new(524, 524), + Interval::new(526, 526), + Interval::new(528, 528), + Interval::new(530, 530), + Interval::new(532, 532), + Interval::new(534, 534), + Interval::new(536, 536), + Interval::new(538, 538), + Interval::new(540, 540), + Interval::new(542, 542), + Interval::new(544, 544), + Interval::new(546, 546), + Interval::new(548, 548), + Interval::new(550, 550), + Interval::new(552, 552), + Interval::new(554, 554), + Interval::new(556, 556), + Interval::new(558, 558), + Interval::new(560, 560), + Interval::new(562, 562), + Interval::new(570, 571), + Interval::new(573, 574), + Interval::new(577, 577), + Interval::new(579, 582), + Interval::new(584, 584), + Interval::new(586, 586), + Interval::new(588, 588), + Interval::new(590, 590), + Interval::new(688, 696), + Interval::new(728, 733), + Interval::new(736, 740), + Interval::new(832, 833), + Interval::new(835, 837), + Interval::new(847, 847), + Interval::new(880, 880), + Interval::new(882, 882), + Interval::new(884, 884), + Interval::new(886, 886), + Interval::new(890, 890), + Interval::new(894, 895), + Interval::new(900, 906), + Interval::new(908, 908), + Interval::new(910, 911), + Interval::new(913, 929), + Interval::new(931, 939), + Interval::new(962, 962), + Interval::new(975, 982), + Interval::new(984, 984), + Interval::new(986, 986), + Interval::new(988, 988), + Interval::new(990, 990), + Interval::new(992, 992), + Interval::new(994, 994), + Interval::new(996, 996), + Interval::new(998, 998), + Interval::new(1000, 1000), + Interval::new(1002, 1002), + Interval::new(1004, 1004), + Interval::new(1006, 1006), + Interval::new(1008, 1010), + Interval::new(1012, 1013), + Interval::new(1015, 1015), + Interval::new(1017, 1018), + Interval::new(1021, 1071), + Interval::new(1120, 1120), + Interval::new(1122, 1122), + Interval::new(1124, 1124), + Interval::new(1126, 1126), + Interval::new(1128, 1128), + Interval::new(1130, 1130), + Interval::new(1132, 1132), + Interval::new(1134, 1134), + Interval::new(1136, 1136), + Interval::new(1138, 1138), + Interval::new(1140, 1140), + Interval::new(1142, 1142), + Interval::new(1144, 1144), + Interval::new(1146, 1146), + Interval::new(1148, 1148), + Interval::new(1150, 1150), + Interval::new(1152, 1152), + Interval::new(1162, 1162), + Interval::new(1164, 1164), + Interval::new(1166, 1166), + Interval::new(1168, 1168), + Interval::new(1170, 1170), + Interval::new(1172, 1172), + Interval::new(1174, 1174), + Interval::new(1176, 1176), + Interval::new(1178, 1178), + Interval::new(1180, 1180), + Interval::new(1182, 1182), + Interval::new(1184, 1184), + Interval::new(1186, 1186), + Interval::new(1188, 1188), + Interval::new(1190, 1190), + Interval::new(1192, 1192), + Interval::new(1194, 1194), + Interval::new(1196, 1196), + Interval::new(1198, 1198), + Interval::new(1200, 1200), + Interval::new(1202, 1202), + Interval::new(1204, 1204), + Interval::new(1206, 1206), + Interval::new(1208, 1208), + Interval::new(1210, 1210), + Interval::new(1212, 1212), + Interval::new(1214, 1214), + Interval::new(1216, 1217), + Interval::new(1219, 1219), + Interval::new(1221, 1221), + Interval::new(1223, 1223), + Interval::new(1225, 1225), + Interval::new(1227, 1227), + Interval::new(1229, 1229), + Interval::new(1232, 1232), + Interval::new(1234, 1234), + Interval::new(1236, 1236), + Interval::new(1238, 1238), + Interval::new(1240, 1240), + Interval::new(1242, 1242), + Interval::new(1244, 1244), + Interval::new(1246, 1246), + Interval::new(1248, 1248), + Interval::new(1250, 1250), + Interval::new(1252, 1252), + Interval::new(1254, 1254), + Interval::new(1256, 1256), + Interval::new(1258, 1258), + Interval::new(1260, 1260), + Interval::new(1262, 1262), + Interval::new(1264, 1264), + Interval::new(1266, 1266), + Interval::new(1268, 1268), + Interval::new(1270, 1270), + Interval::new(1272, 1272), + Interval::new(1274, 1274), + Interval::new(1276, 1276), + Interval::new(1278, 1278), + Interval::new(1280, 1280), + Interval::new(1282, 1282), + Interval::new(1284, 1284), + Interval::new(1286, 1286), + Interval::new(1288, 1288), + Interval::new(1290, 1290), + Interval::new(1292, 1292), + Interval::new(1294, 1294), + Interval::new(1296, 1296), + Interval::new(1298, 1298), + Interval::new(1300, 1300), + Interval::new(1302, 1302), + Interval::new(1304, 1304), + Interval::new(1306, 1306), + Interval::new(1308, 1308), + Interval::new(1310, 1310), + Interval::new(1312, 1312), + Interval::new(1314, 1314), + Interval::new(1316, 1316), + Interval::new(1318, 1318), + Interval::new(1320, 1320), + Interval::new(1322, 1322), + Interval::new(1324, 1324), + Interval::new(1326, 1326), + Interval::new(1329, 1366), + Interval::new(1415, 1415), + Interval::new(1564, 1564), + Interval::new(1653, 1656), + Interval::new(2392, 2399), + Interval::new(2524, 2525), + Interval::new(2527, 2527), + Interval::new(2611, 2611), + Interval::new(2614, 2614), + Interval::new(2649, 2651), + Interval::new(2654, 2654), + Interval::new(2908, 2909), + Interval::new(3635, 3635), + Interval::new(3763, 3763), + Interval::new(3804, 3805), + Interval::new(3852, 3852), + Interval::new(3907, 3907), + Interval::new(3917, 3917), + Interval::new(3922, 3922), + Interval::new(3927, 3927), + Interval::new(3932, 3932), + Interval::new(3945, 3945), + Interval::new(3955, 3955), + Interval::new(3957, 3961), + Interval::new(3969, 3969), + Interval::new(3987, 3987), + Interval::new(3997, 3997), + Interval::new(4002, 4002), + Interval::new(4007, 4007), + Interval::new(4012, 4012), + Interval::new(4025, 4025), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4348, 4348), + Interval::new(4447, 4448), + Interval::new(5112, 5117), + Interval::new(6068, 6069), + Interval::new(6155, 6159), + Interval::new(7296, 7305), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7468, 7470), + Interval::new(7472, 7482), + Interval::new(7484, 7501), + Interval::new(7503, 7530), + Interval::new(7544, 7544), + Interval::new(7579, 7615), + Interval::new(7680, 7680), + Interval::new(7682, 7682), + Interval::new(7684, 7684), + Interval::new(7686, 7686), + Interval::new(7688, 7688), + Interval::new(7690, 7690), + Interval::new(7692, 7692), + Interval::new(7694, 7694), + Interval::new(7696, 7696), + Interval::new(7698, 7698), + Interval::new(7700, 7700), + Interval::new(7702, 7702), + Interval::new(7704, 7704), + Interval::new(7706, 7706), + Interval::new(7708, 7708), + Interval::new(7710, 7710), + Interval::new(7712, 7712), + Interval::new(7714, 7714), + Interval::new(7716, 7716), + Interval::new(7718, 7718), + Interval::new(7720, 7720), + Interval::new(7722, 7722), + Interval::new(7724, 7724), + Interval::new(7726, 7726), + Interval::new(7728, 7728), + Interval::new(7730, 7730), + Interval::new(7732, 7732), + Interval::new(7734, 7734), + Interval::new(7736, 7736), + Interval::new(7738, 7738), + Interval::new(7740, 7740), + Interval::new(7742, 7742), + Interval::new(7744, 7744), + Interval::new(7746, 7746), + Interval::new(7748, 7748), + Interval::new(7750, 7750), + Interval::new(7752, 7752), + Interval::new(7754, 7754), + Interval::new(7756, 7756), + Interval::new(7758, 7758), + Interval::new(7760, 7760), + Interval::new(7762, 7762), + Interval::new(7764, 7764), + Interval::new(7766, 7766), + Interval::new(7768, 7768), + Interval::new(7770, 7770), + Interval::new(7772, 7772), + Interval::new(7774, 7774), + Interval::new(7776, 7776), + Interval::new(7778, 7778), + Interval::new(7780, 7780), + Interval::new(7782, 7782), + Interval::new(7784, 7784), + Interval::new(7786, 7786), + Interval::new(7788, 7788), + Interval::new(7790, 7790), + Interval::new(7792, 7792), + Interval::new(7794, 7794), + Interval::new(7796, 7796), + Interval::new(7798, 7798), + Interval::new(7800, 7800), + Interval::new(7802, 7802), + Interval::new(7804, 7804), + Interval::new(7806, 7806), + Interval::new(7808, 7808), + Interval::new(7810, 7810), + Interval::new(7812, 7812), + Interval::new(7814, 7814), + Interval::new(7816, 7816), + Interval::new(7818, 7818), + Interval::new(7820, 7820), + Interval::new(7822, 7822), + Interval::new(7824, 7824), + Interval::new(7826, 7826), + Interval::new(7828, 7828), + Interval::new(7834, 7835), + Interval::new(7838, 7838), + Interval::new(7840, 7840), + Interval::new(7842, 7842), + Interval::new(7844, 7844), + Interval::new(7846, 7846), + Interval::new(7848, 7848), + Interval::new(7850, 7850), + Interval::new(7852, 7852), + Interval::new(7854, 7854), + Interval::new(7856, 7856), + Interval::new(7858, 7858), + Interval::new(7860, 7860), + Interval::new(7862, 7862), + Interval::new(7864, 7864), + Interval::new(7866, 7866), + Interval::new(7868, 7868), + Interval::new(7870, 7870), + Interval::new(7872, 7872), + Interval::new(7874, 7874), + Interval::new(7876, 7876), + Interval::new(7878, 7878), + Interval::new(7880, 7880), + Interval::new(7882, 7882), + Interval::new(7884, 7884), + Interval::new(7886, 7886), + Interval::new(7888, 7888), + Interval::new(7890, 7890), + Interval::new(7892, 7892), + Interval::new(7894, 7894), + Interval::new(7896, 7896), + Interval::new(7898, 7898), + Interval::new(7900, 7900), + Interval::new(7902, 7902), + Interval::new(7904, 7904), + Interval::new(7906, 7906), + Interval::new(7908, 7908), + Interval::new(7910, 7910), + Interval::new(7912, 7912), + Interval::new(7914, 7914), + Interval::new(7916, 7916), + Interval::new(7918, 7918), + Interval::new(7920, 7920), + Interval::new(7922, 7922), + Interval::new(7924, 7924), + Interval::new(7926, 7926), + Interval::new(7928, 7928), + Interval::new(7930, 7930), + Interval::new(7932, 7932), + Interval::new(7934, 7934), + Interval::new(7944, 7951), + Interval::new(7960, 7965), + Interval::new(7976, 7983), + Interval::new(7992, 7999), + Interval::new(8008, 8013), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8031), + Interval::new(8040, 8047), + Interval::new(8049, 8049), + Interval::new(8051, 8051), + Interval::new(8053, 8053), + Interval::new(8055, 8055), + Interval::new(8057, 8057), + Interval::new(8059, 8059), + Interval::new(8061, 8061), + Interval::new(8064, 8111), + Interval::new(8114, 8116), + Interval::new(8119, 8132), + Interval::new(8135, 8143), + Interval::new(8147, 8147), + Interval::new(8152, 8155), + Interval::new(8157, 8159), + Interval::new(8163, 8163), + Interval::new(8168, 8175), + Interval::new(8178, 8180), + Interval::new(8183, 8190), + Interval::new(8192, 8207), + Interval::new(8209, 8209), + Interval::new(8215, 8215), + Interval::new(8228, 8230), + Interval::new(8234, 8239), + Interval::new(8243, 8244), + Interval::new(8246, 8247), + Interval::new(8252, 8252), + Interval::new(8254, 8254), + Interval::new(8263, 8265), + Interval::new(8279, 8279), + Interval::new(8287, 8305), + Interval::new(8308, 8334), + Interval::new(8336, 8348), + Interval::new(8360, 8360), + Interval::new(8448, 8451), + Interval::new(8453, 8455), + Interval::new(8457, 8467), + Interval::new(8469, 8470), + Interval::new(8473, 8477), + Interval::new(8480, 8482), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8495, 8505), + Interval::new(8507, 8512), + Interval::new(8517, 8521), + Interval::new(8528, 8575), + Interval::new(8579, 8579), + Interval::new(8585, 8585), + Interval::new(8748, 8749), + Interval::new(8751, 8752), + Interval::new(9001, 9002), + Interval::new(9312, 9450), + Interval::new(10764, 10764), + Interval::new(10868, 10870), + Interval::new(10972, 10972), + Interval::new(11264, 11311), + Interval::new(11360, 11360), + Interval::new(11362, 11364), + Interval::new(11367, 11367), + Interval::new(11369, 11369), + Interval::new(11371, 11371), + Interval::new(11373, 11376), + Interval::new(11378, 11378), + Interval::new(11381, 11381), + Interval::new(11388, 11392), + Interval::new(11394, 11394), + Interval::new(11396, 11396), + Interval::new(11398, 11398), + Interval::new(11400, 11400), + Interval::new(11402, 11402), + Interval::new(11404, 11404), + Interval::new(11406, 11406), + Interval::new(11408, 11408), + Interval::new(11410, 11410), + Interval::new(11412, 11412), + Interval::new(11414, 11414), + Interval::new(11416, 11416), + Interval::new(11418, 11418), + Interval::new(11420, 11420), + Interval::new(11422, 11422), + Interval::new(11424, 11424), + Interval::new(11426, 11426), + Interval::new(11428, 11428), + Interval::new(11430, 11430), + Interval::new(11432, 11432), + Interval::new(11434, 11434), + Interval::new(11436, 11436), + Interval::new(11438, 11438), + Interval::new(11440, 11440), + Interval::new(11442, 11442), + Interval::new(11444, 11444), + Interval::new(11446, 11446), + Interval::new(11448, 11448), + Interval::new(11450, 11450), + Interval::new(11452, 11452), + Interval::new(11454, 11454), + Interval::new(11456, 11456), + Interval::new(11458, 11458), + Interval::new(11460, 11460), + Interval::new(11462, 11462), + Interval::new(11464, 11464), + Interval::new(11466, 11466), + Interval::new(11468, 11468), + Interval::new(11470, 11470), + Interval::new(11472, 11472), + Interval::new(11474, 11474), + Interval::new(11476, 11476), + Interval::new(11478, 11478), + Interval::new(11480, 11480), + Interval::new(11482, 11482), + Interval::new(11484, 11484), + Interval::new(11486, 11486), + Interval::new(11488, 11488), + Interval::new(11490, 11490), + Interval::new(11499, 11499), + Interval::new(11501, 11501), + Interval::new(11506, 11506), + Interval::new(11631, 11631), + Interval::new(11935, 11935), + Interval::new(12019, 12019), + Interval::new(12032, 12245), + Interval::new(12288, 12288), + Interval::new(12342, 12342), + Interval::new(12344, 12346), + Interval::new(12443, 12444), + Interval::new(12447, 12447), + Interval::new(12543, 12543), + Interval::new(12593, 12686), + Interval::new(12690, 12703), + Interval::new(12800, 12830), + Interval::new(12832, 12871), + Interval::new(12880, 12926), + Interval::new(12928, 13311), + Interval::new(42560, 42560), + Interval::new(42562, 42562), + Interval::new(42564, 42564), + Interval::new(42566, 42566), + Interval::new(42568, 42568), + Interval::new(42570, 42570), + Interval::new(42572, 42572), + Interval::new(42574, 42574), + Interval::new(42576, 42576), + Interval::new(42578, 42578), + Interval::new(42580, 42580), + Interval::new(42582, 42582), + Interval::new(42584, 42584), + Interval::new(42586, 42586), + Interval::new(42588, 42588), + Interval::new(42590, 42590), + Interval::new(42592, 42592), + Interval::new(42594, 42594), + Interval::new(42596, 42596), + Interval::new(42598, 42598), + Interval::new(42600, 42600), + Interval::new(42602, 42602), + Interval::new(42604, 42604), + Interval::new(42624, 42624), + Interval::new(42626, 42626), + Interval::new(42628, 42628), + Interval::new(42630, 42630), + Interval::new(42632, 42632), + Interval::new(42634, 42634), + Interval::new(42636, 42636), + Interval::new(42638, 42638), + Interval::new(42640, 42640), + Interval::new(42642, 42642), + Interval::new(42644, 42644), + Interval::new(42646, 42646), + Interval::new(42648, 42648), + Interval::new(42650, 42650), + Interval::new(42652, 42653), + Interval::new(42786, 42786), + Interval::new(42788, 42788), + Interval::new(42790, 42790), + Interval::new(42792, 42792), + Interval::new(42794, 42794), + Interval::new(42796, 42796), + Interval::new(42798, 42798), + Interval::new(42802, 42802), + Interval::new(42804, 42804), + Interval::new(42806, 42806), + Interval::new(42808, 42808), + Interval::new(42810, 42810), + Interval::new(42812, 42812), + Interval::new(42814, 42814), + Interval::new(42816, 42816), + Interval::new(42818, 42818), + Interval::new(42820, 42820), + Interval::new(42822, 42822), + Interval::new(42824, 42824), + Interval::new(42826, 42826), + Interval::new(42828, 42828), + Interval::new(42830, 42830), + Interval::new(42832, 42832), + Interval::new(42834, 42834), + Interval::new(42836, 42836), + Interval::new(42838, 42838), + Interval::new(42840, 42840), + Interval::new(42842, 42842), + Interval::new(42844, 42844), + Interval::new(42846, 42846), + Interval::new(42848, 42848), + Interval::new(42850, 42850), + Interval::new(42852, 42852), + Interval::new(42854, 42854), + Interval::new(42856, 42856), + Interval::new(42858, 42858), + Interval::new(42860, 42860), + Interval::new(42862, 42862), + Interval::new(42864, 42864), + Interval::new(42873, 42873), + Interval::new(42875, 42875), + Interval::new(42877, 42878), + Interval::new(42880, 42880), + Interval::new(42882, 42882), + Interval::new(42884, 42884), + Interval::new(42886, 42886), + Interval::new(42891, 42891), + Interval::new(42893, 42893), + Interval::new(42896, 42896), + Interval::new(42898, 42898), + Interval::new(42902, 42902), + Interval::new(42904, 42904), + Interval::new(42906, 42906), + Interval::new(42908, 42908), + Interval::new(42910, 42910), + Interval::new(42912, 42912), + Interval::new(42914, 42914), + Interval::new(42916, 42916), + Interval::new(42918, 42918), + Interval::new(42920, 42920), + Interval::new(42922, 42926), + Interval::new(42928, 42932), + Interval::new(42934, 42934), + Interval::new(42936, 42936), + Interval::new(42938, 42938), + Interval::new(42940, 42940), + Interval::new(42942, 42942), + Interval::new(42944, 42944), + Interval::new(42946, 42946), + Interval::new(42948, 42951), + Interval::new(42953, 42953), + Interval::new(42955, 42956), + Interval::new(42958, 42958), + Interval::new(42960, 42960), + Interval::new(42962, 42962), + Interval::new(42964, 42964), + Interval::new(42966, 42966), + Interval::new(42968, 42968), + Interval::new(42970, 42970), + Interval::new(42972, 42972), + Interval::new(42993, 42997), + Interval::new(43000, 43001), + Interval::new(43868, 43871), + Interval::new(43881, 43881), + Interval::new(43888, 43967), + Interval::new(63744, 64013), + Interval::new(64016, 64016), + Interval::new(64018, 64018), + Interval::new(64021, 64030), + Interval::new(64032, 64032), + Interval::new(64034, 64034), + Interval::new(64037, 64038), + Interval::new(64042, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64285), + Interval::new(64287, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65020), + Interval::new(65024, 65049), + Interval::new(65072, 65092), + Interval::new(65095, 65106), + Interval::new(65108, 65126), + Interval::new(65128, 65131), + Interval::new(65136, 65138), + Interval::new(65140, 65140), + Interval::new(65142, 65276), + Interval::new(65279, 65279), + Interval::new(65281, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65504, 65510), + Interval::new(65512, 65518), + Interval::new(65520, 65528), + Interval::new(66560, 66599), + Interval::new(66736, 66771), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(67457, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(68736, 68786), + Interval::new(68944, 68965), + Interval::new(71840, 71871), + Interval::new(93760, 93791), + Interval::new(93856, 93880), + Interval::new(113824, 113827), + Interval::new(117974, 118009), + Interval::new(119134, 119140), + Interval::new(119155, 119162), + Interval::new(119227, 119232), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120779), + Interval::new(120782, 120831), + Interval::new(122928, 122989), + Interval::new(125184, 125217), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(127232, 127242), + Interval::new(127248, 127278), + Interval::new(127280, 127311), + Interval::new(127338, 127340), + Interval::new(127376, 127376), + Interval::new(127488, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127568, 127569), + Interval::new(130032, 130041), + Interval::new(194560, 195101), + Interval::new(917504, 921599), +]; + +/// Return the code point ranges of the 'Changes_When_NFKC_Casefolded' Unicode property. +pub(crate) fn changes_when_nfkc_casefolded_ranges() -> &'static [Interval] { + &CHANGES_WHEN_NFKC_CASEFOLDED +} + +const BIDI_MIRRORED: [Interval; 114] = [ + Interval::new(40, 41), + Interval::new(60, 60), + Interval::new(62, 62), + Interval::new(91, 91), + Interval::new(93, 93), + Interval::new(123, 123), + Interval::new(125, 125), + Interval::new(171, 171), + Interval::new(187, 187), + Interval::new(3898, 3901), + Interval::new(5787, 5788), + Interval::new(8249, 8250), + Interval::new(8261, 8262), + Interval::new(8317, 8318), + Interval::new(8333, 8334), + Interval::new(8512, 8512), + Interval::new(8705, 8708), + Interval::new(8712, 8717), + Interval::new(8721, 8721), + Interval::new(8725, 8726), + Interval::new(8730, 8733), + Interval::new(8735, 8738), + Interval::new(8740, 8740), + Interval::new(8742, 8742), + Interval::new(8747, 8755), + Interval::new(8761, 8761), + Interval::new(8763, 8780), + Interval::new(8786, 8789), + Interval::new(8799, 8800), + Interval::new(8802, 8802), + Interval::new(8804, 8811), + Interval::new(8813, 8844), + Interval::new(8847, 8850), + Interval::new(8856, 8856), + Interval::new(8866, 8867), + Interval::new(8870, 8888), + Interval::new(8894, 8895), + Interval::new(8905, 8909), + Interval::new(8912, 8913), + Interval::new(8918, 8941), + Interval::new(8944, 8959), + Interval::new(8968, 8971), + Interval::new(8992, 8993), + Interval::new(9001, 9002), + Interval::new(10088, 10101), + Interval::new(10176, 10176), + Interval::new(10179, 10182), + Interval::new(10184, 10185), + Interval::new(10187, 10189), + Interval::new(10195, 10198), + Interval::new(10204, 10206), + Interval::new(10210, 10223), + Interval::new(10627, 10648), + Interval::new(10651, 10656), + Interval::new(10658, 10671), + Interval::new(10680, 10680), + Interval::new(10688, 10693), + Interval::new(10697, 10697), + Interval::new(10702, 10706), + Interval::new(10708, 10709), + Interval::new(10712, 10716), + Interval::new(10721, 10721), + Interval::new(10723, 10725), + Interval::new(10728, 10729), + Interval::new(10740, 10745), + Interval::new(10748, 10749), + Interval::new(10762, 10780), + Interval::new(10782, 10785), + Interval::new(10788, 10788), + Interval::new(10790, 10790), + Interval::new(10793, 10793), + Interval::new(10795, 10798), + Interval::new(10804, 10805), + Interval::new(10812, 10814), + Interval::new(10839, 10840), + Interval::new(10852, 10853), + Interval::new(10858, 10861), + Interval::new(10863, 10864), + Interval::new(10867, 10868), + Interval::new(10873, 10915), + Interval::new(10918, 10925), + Interval::new(10927, 10966), + Interval::new(10972, 10972), + Interval::new(10974, 10974), + Interval::new(10978, 10982), + Interval::new(10988, 10990), + Interval::new(10995, 10995), + Interval::new(10999, 11003), + Interval::new(11005, 11005), + Interval::new(11262, 11262), + Interval::new(11778, 11781), + Interval::new(11785, 11786), + Interval::new(11788, 11789), + Interval::new(11804, 11805), + Interval::new(11808, 11817), + Interval::new(11861, 11868), + Interval::new(12296, 12305), + Interval::new(12308, 12315), + Interval::new(65113, 65118), + Interval::new(65124, 65125), + Interval::new(65288, 65289), + Interval::new(65308, 65308), + Interval::new(65310, 65310), + Interval::new(65339, 65339), + Interval::new(65341, 65341), + Interval::new(65371, 65371), + Interval::new(65373, 65373), + Interval::new(65375, 65376), + Interval::new(65378, 65379), + Interval::new(120539, 120539), + Interval::new(120597, 120597), + Interval::new(120655, 120655), + Interval::new(120713, 120713), + Interval::new(120771, 120771), +]; + +/// Return the code point ranges of the 'Bidi_Mirrored' Unicode property. +pub(crate) fn bidi_mirrored_ranges() -> &'static [Interval] { + &BIDI_MIRRORED +} + +pub(crate) const ASCII: [Interval; 1] = [Interval::new(0, 127)]; + +/// Return the code point ranges of the 'ASCII' Unicode property. +pub(crate) fn ascii_ranges() -> &'static [Interval] { + &ASCII +} + +pub(crate) const ANY: [Interval; 1] = [Interval::new(0, 1114111)]; + +/// Return the code point ranges of the 'ANY' Unicode property. +pub(crate) fn any_ranges() -> &'static [Interval] { + &ANY +} + +const ASSIGNED: [Interval; 735] = [ + Interval::new(0, 887), + Interval::new(890, 895), + Interval::new(900, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1418), + Interval::new(1421, 1423), + Interval::new(1425, 1479), + Interval::new(1488, 1514), + Interval::new(1519, 1524), + Interval::new(1536, 1805), + Interval::new(1807, 1866), + Interval::new(1869, 1969), + Interval::new(1984, 2042), + Interval::new(2045, 2093), + Interval::new(2096, 2110), + Interval::new(2112, 2139), + Interval::new(2142, 2142), + Interval::new(2144, 2154), + Interval::new(2160, 2193), + Interval::new(2199, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2492, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2510), + Interval::new(2519, 2519), + Interval::new(2524, 2525), + Interval::new(2527, 2531), + Interval::new(2534, 2558), + Interval::new(2561, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2620, 2620), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2662, 2678), + Interval::new(2689, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2748, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2765), + Interval::new(2768, 2768), + Interval::new(2784, 2787), + Interval::new(2790, 2801), + Interval::new(2809, 2815), + Interval::new(2817, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2876, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2893), + Interval::new(2901, 2903), + Interval::new(2908, 2909), + Interval::new(2911, 2915), + Interval::new(2918, 2935), + Interval::new(2946, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3021), + Interval::new(3024, 3024), + Interval::new(3031, 3031), + Interval::new(3046, 3066), + Interval::new(3072, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3132, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3171), + Interval::new(3174, 3183), + Interval::new(3191, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3260, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3292, 3294), + Interval::new(3296, 3299), + Interval::new(3302, 3311), + Interval::new(3313, 3315), + Interval::new(3328, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3407), + Interval::new(3412, 3427), + Interval::new(3430, 3455), + Interval::new(3457, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3530, 3530), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3558, 3567), + Interval::new(3570, 3572), + Interval::new(3585, 3642), + Interval::new(3647, 3675), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3784, 3790), + Interval::new(3792, 3801), + Interval::new(3804, 3807), + Interval::new(3840, 3911), + Interval::new(3913, 3948), + Interval::new(3953, 3991), + Interval::new(3993, 4028), + Interval::new(4030, 4044), + Interval::new(4046, 4058), + Interval::new(4096, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4957, 4988), + Interval::new(4992, 5017), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5120, 5788), + Interval::new(5792, 5880), + Interval::new(5888, 5909), + Interval::new(5919, 5942), + Interval::new(5952, 5971), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6002, 6003), + Interval::new(6016, 6109), + Interval::new(6112, 6121), + Interval::new(6128, 6137), + Interval::new(6144, 6169), + Interval::new(6176, 6264), + Interval::new(6272, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6432, 6443), + Interval::new(6448, 6459), + Interval::new(6464, 6464), + Interval::new(6468, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6608, 6618), + Interval::new(6622, 6683), + Interval::new(6686, 6750), + Interval::new(6752, 6780), + Interval::new(6783, 6793), + Interval::new(6800, 6809), + Interval::new(6816, 6829), + Interval::new(6832, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6988), + Interval::new(6990, 7155), + Interval::new(7164, 7223), + Interval::new(7227, 7241), + Interval::new(7245, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7367), + Interval::new(7376, 7418), + Interval::new(7424, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8132), + Interval::new(8134, 8147), + Interval::new(8150, 8155), + Interval::new(8157, 8175), + Interval::new(8178, 8180), + Interval::new(8182, 8190), + Interval::new(8192, 8292), + Interval::new(8294, 8305), + Interval::new(8308, 8334), + Interval::new(8336, 8348), + Interval::new(8352, 8385), + Interval::new(8400, 8432), + Interval::new(8448, 8587), + Interval::new(8592, 9257), + Interval::new(9280, 9290), + Interval::new(9312, 11123), + Interval::new(11126, 11507), + Interval::new(11513, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11632), + Interval::new(11647, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(11744, 11869), + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), + Interval::new(12272, 12351), + Interval::new(12353, 12438), + Interval::new(12441, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12688, 12773), + Interval::new(12783, 12830), + Interval::new(12832, 42124), + Interval::new(42128, 42182), + Interval::new(42192, 42539), + Interval::new(42560, 42743), + Interval::new(42752, 42972), + Interval::new(42993, 43052), + Interval::new(43056, 43065), + Interval::new(43072, 43127), + Interval::new(43136, 43205), + Interval::new(43214, 43225), + Interval::new(43232, 43347), + Interval::new(43359, 43388), + Interval::new(43392, 43469), + Interval::new(43471, 43481), + Interval::new(43486, 43518), + Interval::new(43520, 43574), + Interval::new(43584, 43597), + Interval::new(43600, 43609), + Interval::new(43612, 43714), + Interval::new(43739, 43766), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43883), + Interval::new(43888, 44013), + Interval::new(44016, 44025), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(55296, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64975), + Interval::new(65008, 65049), + Interval::new(65056, 65106), + Interval::new(65108, 65126), + Interval::new(65128, 65131), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65279, 65279), + Interval::new(65281, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65504, 65510), + Interval::new(65512, 65518), + Interval::new(65529, 65533), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65792, 65794), + Interval::new(65799, 65843), + Interval::new(65847, 65934), + Interval::new(65936, 65948), + Interval::new(65952, 65952), + Interval::new(66000, 66045), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66272, 66299), + Interval::new(66304, 66339), + Interval::new(66349, 66378), + Interval::new(66384, 66426), + Interval::new(66432, 66461), + Interval::new(66463, 66499), + Interval::new(66504, 66517), + Interval::new(66560, 66717), + Interval::new(66720, 66729), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66927, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67671, 67742), + Interval::new(67751, 67759), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67835, 67867), + Interval::new(67871, 67897), + Interval::new(67903, 67929), + Interval::new(67968, 68023), + Interval::new(68028, 68047), + Interval::new(68050, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68152, 68154), + Interval::new(68159, 68168), + Interval::new(68176, 68184), + Interval::new(68192, 68255), + Interval::new(68288, 68326), + Interval::new(68331, 68342), + Interval::new(68352, 68405), + Interval::new(68409, 68437), + Interval::new(68440, 68466), + Interval::new(68472, 68497), + Interval::new(68505, 68508), + Interval::new(68521, 68527), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68858, 68903), + Interval::new(68912, 68921), + Interval::new(68928, 68965), + Interval::new(68969, 68997), + Interval::new(69006, 69007), + Interval::new(69216, 69246), + Interval::new(69248, 69289), + Interval::new(69291, 69293), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69328, 69336), + Interval::new(69370, 69415), + Interval::new(69424, 69465), + Interval::new(69488, 69513), + Interval::new(69552, 69579), + Interval::new(69600, 69622), + Interval::new(69632, 69709), + Interval::new(69714, 69749), + Interval::new(69759, 69826), + Interval::new(69837, 69837), + Interval::new(69840, 69864), + Interval::new(69872, 69881), + Interval::new(69888, 69940), + Interval::new(69942, 69959), + Interval::new(69968, 70006), + Interval::new(70016, 70111), + Interval::new(70113, 70132), + Interval::new(70144, 70161), + Interval::new(70163, 70209), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70313), + Interval::new(70320, 70378), + Interval::new(70384, 70393), + Interval::new(70400, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70459, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70480, 70480), + Interval::new(70487, 70487), + Interval::new(70493, 70499), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70613), + Interval::new(70615, 70616), + Interval::new(70625, 70626), + Interval::new(70656, 70747), + Interval::new(70749, 70753), + Interval::new(70784, 70855), + Interval::new(70864, 70873), + Interval::new(71040, 71093), + Interval::new(71096, 71133), + Interval::new(71168, 71236), + Interval::new(71248, 71257), + Interval::new(71264, 71276), + Interval::new(71296, 71353), + Interval::new(71360, 71369), + Interval::new(71376, 71395), + Interval::new(71424, 71450), + Interval::new(71453, 71467), + Interval::new(71472, 71494), + Interval::new(71680, 71739), + Interval::new(71840, 71922), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71989), + Interval::new(71991, 71992), + Interval::new(71995, 72006), + Interval::new(72016, 72025), + Interval::new(72096, 72103), + Interval::new(72106, 72151), + Interval::new(72154, 72164), + Interval::new(72192, 72263), + Interval::new(72272, 72354), + Interval::new(72368, 72440), + Interval::new(72448, 72457), + Interval::new(72544, 72551), + Interval::new(72640, 72673), + Interval::new(72688, 72697), + Interval::new(72704, 72712), + Interval::new(72714, 72758), + Interval::new(72760, 72773), + Interval::new(72784, 72812), + Interval::new(72816, 72847), + Interval::new(72850, 72871), + Interval::new(72873, 72886), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73031), + Interval::new(73040, 73049), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73112), + Interval::new(73120, 73129), + Interval::new(73136, 73179), + Interval::new(73184, 73193), + Interval::new(73440, 73464), + Interval::new(73472, 73488), + Interval::new(73490, 73530), + Interval::new(73534, 73562), + Interval::new(73648, 73648), + Interval::new(73664, 73713), + Interval::new(73727, 74649), + Interval::new(74752, 74862), + Interval::new(74864, 74868), + Interval::new(74880, 75075), + Interval::new(77712, 77810), + Interval::new(77824, 78933), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90425), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92768, 92777), + Interval::new(92782, 92862), + Interval::new(92864, 92873), + Interval::new(92880, 92909), + Interval::new(92912, 92917), + Interval::new(92928, 92997), + Interval::new(93008, 93017), + Interval::new(93019, 93025), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93561), + Interval::new(93760, 93850), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94031, 94087), + Interval::new(94095, 94111), + Interval::new(94176, 94180), + Interval::new(94192, 94198), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113820, 113827), + Interval::new(117760, 118012), + Interval::new(118016, 118451), + Interval::new(118458, 118480), + Interval::new(118496, 118512), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(118608, 118723), + Interval::new(118784, 119029), + Interval::new(119040, 119078), + Interval::new(119081, 119274), + Interval::new(119296, 119365), + Interval::new(119488, 119507), + Interval::new(119520, 119539), + Interval::new(119552, 119638), + Interval::new(119648, 119672), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120779), + Interval::new(120782, 121483), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(122928, 122989), + Interval::new(123023, 123023), + Interval::new(123136, 123180), + Interval::new(123184, 123197), + Interval::new(123200, 123209), + Interval::new(123214, 123215), + Interval::new(123536, 123566), + Interval::new(123584, 123641), + Interval::new(123647, 123647), + Interval::new(124112, 124153), + Interval::new(124368, 124410), + Interval::new(124415, 124415), + Interval::new(124608, 124638), + Interval::new(124640, 124661), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125127, 125142), + Interval::new(125184, 125259), + Interval::new(125264, 125273), + Interval::new(125278, 125279), + Interval::new(126065, 126132), + Interval::new(126209, 126269), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(126704, 126705), + Interval::new(126976, 127019), + Interval::new(127024, 127123), + Interval::new(127136, 127150), + Interval::new(127153, 127167), + Interval::new(127169, 127183), + Interval::new(127185, 127221), + Interval::new(127232, 127405), + Interval::new(127462, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127568, 127569), + Interval::new(127584, 127589), + Interval::new(127744, 128728), + Interval::new(128732, 128748), + Interval::new(128752, 128764), + Interval::new(128768, 128985), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129024, 129035), + Interval::new(129040, 129095), + Interval::new(129104, 129113), + Interval::new(129120, 129159), + Interval::new(129168, 129197), + Interval::new(129200, 129211), + Interval::new(129216, 129217), + Interval::new(129232, 129240), + Interval::new(129280, 129623), + Interval::new(129632, 129645), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), + Interval::new(129792, 129938), + Interval::new(129940, 130042), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), + Interval::new(917505, 917505), + Interval::new(917536, 917631), + Interval::new(917760, 917999), + Interval::new(983040, 1048573), + Interval::new(1048576, 1114109), +]; + +/// Return the code point ranges of the 'ANY' Unicode property. +pub(crate) fn assigned_ranges() -> &'static [Interval] { + &ASSIGNED +} + +pub(crate) fn binary_property_ranges(value: &UnicodePropertyBinary) -> &'static [Interval] { + use UnicodePropertyBinary::*; + match value { + Alphabetic => alphabetic_ranges(), + CaseIgnorable => case_ignorable_ranges(), + Cased => cased_ranges(), + ChangesWhenCasefolded => changes_when_casefolded_ranges(), + ChangesWhenCasemapped => changes_when_casemapped_ranges(), + ChangesWhenLowercased => changes_when_lowercased_ranges(), + ChangesWhenTitlecased => changes_when_titlecased_ranges(), + ChangesWhenUppercased => changes_when_uppercased_ranges(), + DefaultIgnorableCodePoint => default_ignorable_code_point_ranges(), + GraphemeBase => grapheme_base_ranges(), + GraphemeExtend => grapheme_extend_ranges(), + IDContinue => id_continue_ranges(), + IDStart => id_start_ranges(), + Math => math_ranges(), + XIDContinue => xid_continue_ranges(), + XIDStart => xid_start_ranges(), + ASCIIHexDigit => ascii_hex_digit_ranges(), + BidiControl => bidi_control_ranges(), + Dash => dash_ranges(), + Deprecated => deprecated_ranges(), + Diacritic => diacritic_ranges(), + Extender => extender_ranges(), + HexDigit => hex_digit_ranges(), + IDSBinaryOperator => ids_binary_operator_ranges(), + IDSTrinaryOperator => ids_trinary_operator_ranges(), + Ideographic => ideographic_ranges(), + JoinControl => join_control_ranges(), + LogicalOrderException => logical_order_exception_ranges(), + Lowercase => lowercase_ranges(), + NoncharacterCodePoint => noncharacter_code_point_ranges(), + PatternSyntax => pattern_syntax_ranges(), + PatternWhiteSpace => pattern_white_space_ranges(), + QuotationMark => quotation_mark_ranges(), + Radical => radical_ranges(), + RegionalIndicator => regional_indicator_ranges(), + SentenceTerminal => sentence_terminal_ranges(), + SoftDotted => soft_dotted_ranges(), + TerminalPunctuation => terminal_punctuation_ranges(), + UnifiedIdeograph => unified_ideograph_ranges(), + Uppercase => uppercase_ranges(), + VariationSelector => variation_selector_ranges(), + WhiteSpace => white_space_ranges(), + Emoji => emoji_ranges(), + EmojiComponent => emoji_component_ranges(), + EmojiModifier => emoji_modifier_ranges(), + EmojiModifierBase => emoji_modifier_base_ranges(), + EmojiPresentation => emoji_presentation_ranges(), + ExtendedPictographic => extended_pictographic_ranges(), + ChangesWhenNFKCCasefolded => changes_when_nfkc_casefolded_ranges(), + BidiMirrored => bidi_mirrored_ranges(), + Ascii => ascii_ranges(), + Any => any_ranges(), + Assigned => assigned_ranges(), + } +} + +#[derive(Debug, Clone, Copy)] +pub enum UnicodePropertyBinary { + Alphabetic, + CaseIgnorable, + Cased, + ChangesWhenCasefolded, + ChangesWhenCasemapped, + ChangesWhenLowercased, + ChangesWhenTitlecased, + ChangesWhenUppercased, + DefaultIgnorableCodePoint, + GraphemeBase, + GraphemeExtend, + IDContinue, + IDStart, + Math, + XIDContinue, + XIDStart, + ASCIIHexDigit, + BidiControl, + Dash, + Deprecated, + Diacritic, + Extender, + HexDigit, + IDSBinaryOperator, + IDSTrinaryOperator, + Ideographic, + JoinControl, + LogicalOrderException, + Lowercase, + NoncharacterCodePoint, + PatternSyntax, + PatternWhiteSpace, + QuotationMark, + Radical, + RegionalIndicator, + SentenceTerminal, + SoftDotted, + TerminalPunctuation, + UnifiedIdeograph, + Uppercase, + VariationSelector, + WhiteSpace, + Emoji, + EmojiComponent, + EmojiModifier, + EmojiModifierBase, + EmojiPresentation, + ExtendedPictographic, + ChangesWhenNFKCCasefolded, + BidiMirrored, + Ascii, + Any, + Assigned, +} + +pub fn unicode_property_binary_from_str(s: &str) -> Option { + use UnicodePropertyBinary::*; + match s { + "Alpha" | "Alphabetic" => Some(Alphabetic), + "CI" | "Case_Ignorable" => Some(CaseIgnorable), + "Cased" => Some(Cased), + "CWCF" | "Changes_When_Casefolded" => Some(ChangesWhenCasefolded), + "CWCM" | "Changes_When_Casemapped" => Some(ChangesWhenCasemapped), + "CWL" | "Changes_When_Lowercased" => Some(ChangesWhenLowercased), + "CWT" | "Changes_When_Titlecased" => Some(ChangesWhenTitlecased), + "CWU" | "Changes_When_Uppercased" => Some(ChangesWhenUppercased), + "DI" | "Default_Ignorable_Code_Point" => Some(DefaultIgnorableCodePoint), + "Gr_Base" | "Grapheme_Base" => Some(GraphemeBase), + "Gr_Ext" | "Grapheme_Extend" => Some(GraphemeExtend), + "IDC" | "ID_Continue" => Some(IDContinue), + "IDS" | "ID_Start" => Some(IDStart), + "Math" => Some(Math), + "XIDC" | "XID_Continue" => Some(XIDContinue), + "XIDS" | "XID_Start" => Some(XIDStart), + "AHex" | "ASCII_Hex_Digit" => Some(ASCIIHexDigit), + "Bidi_C" | "Bidi_Control" => Some(BidiControl), + "Dash" => Some(Dash), + "Dep" | "Deprecated" => Some(Deprecated), + "Dia" | "Diacritic" => Some(Diacritic), + "Ext" | "Extender" => Some(Extender), + "Hex" | "Hex_Digit" => Some(HexDigit), + "IDSB" | "IDS_Binary_Operator" => Some(IDSBinaryOperator), + "IDST" | "IDS_Trinary_Operator" => Some(IDSTrinaryOperator), + "Ideo" | "Ideographic" => Some(Ideographic), + "Join_C" | "Join_Control" => Some(JoinControl), + "LOE" | "Logical_Order_Exception" => Some(LogicalOrderException), + "Lower" | "Lowercase" => Some(Lowercase), + "NChar" | "Noncharacter_Code_Point" => Some(NoncharacterCodePoint), + "Pat_Syn" | "Pattern_Syntax" => Some(PatternSyntax), + "Pat_WS" | "Pattern_White_Space" => Some(PatternWhiteSpace), + "QMark" | "Quotation_Mark" => Some(QuotationMark), + "Radical" => Some(Radical), + "RI" | "Regional_Indicator" => Some(RegionalIndicator), + "STerm" | "Sentence_Terminal" => Some(SentenceTerminal), + "SD" | "Soft_Dotted" => Some(SoftDotted), + "Term" | "Terminal_Punctuation" => Some(TerminalPunctuation), + "UIdeo" | "Unified_Ideograph" => Some(UnifiedIdeograph), + "Upper" | "Uppercase" => Some(Uppercase), + "VS" | "Variation_Selector" => Some(VariationSelector), + "space" | "White_Space" => Some(WhiteSpace), + "Emoji" => Some(Emoji), + "EComp" | "Emoji_Component" => Some(EmojiComponent), + "EMod" | "Emoji_Modifier" => Some(EmojiModifier), + "EBase" | "Emoji_Modifier_Base" => Some(EmojiModifierBase), + "EPres" | "Emoji_Presentation" => Some(EmojiPresentation), + "ExtPict" | "Extended_Pictographic" => Some(ExtendedPictographic), + "CWKCF" | "Changes_When_NFKC_Casefolded" => Some(ChangesWhenNFKCCasefolded), + "Bidi_M" | "Bidi_Mirrored" => Some(BidiMirrored), + "ASCII" => Some(Ascii), + "Any" => Some(Any), + "Assigned" => Some(Assigned), + _ => None, + } +} + +pub(crate) const FOLDS: [FoldRange; 208] = [ + FoldRange::from(0x41, 26, 32, 1), + FoldRange::from(0xB5, 1, 775, 1), + FoldRange::from(0xC0, 23, 32, 1), + FoldRange::from(0xD8, 7, 32, 1), + FoldRange::from(0x100, 47, 1, 2), + FoldRange::from(0x132, 5, 1, 2), + FoldRange::from(0x139, 15, 1, 2), + FoldRange::from(0x14A, 45, 1, 2), + FoldRange::from(0x178, 1, -121, 1), + FoldRange::from(0x179, 5, 1, 2), + FoldRange::from(0x17F, 1, -268, 1), + FoldRange::from(0x181, 1, 210, 1), + FoldRange::from(0x182, 3, 1, 2), + FoldRange::from(0x186, 1, 206, 1), + FoldRange::from(0x187, 1, 1, 1), + FoldRange::from(0x189, 2, 205, 1), + FoldRange::from(0x18B, 1, 1, 1), + FoldRange::from(0x18E, 1, 79, 1), + FoldRange::from(0x18F, 1, 202, 1), + FoldRange::from(0x190, 1, 203, 1), + FoldRange::from(0x191, 1, 1, 1), + FoldRange::from(0x193, 1, 205, 1), + FoldRange::from(0x194, 1, 207, 1), + FoldRange::from(0x196, 1, 211, 1), + FoldRange::from(0x197, 1, 209, 1), + FoldRange::from(0x198, 1, 1, 1), + FoldRange::from(0x19C, 1, 211, 1), + FoldRange::from(0x19D, 1, 213, 1), + FoldRange::from(0x19F, 1, 214, 1), + FoldRange::from(0x1A0, 5, 1, 2), + FoldRange::from(0x1A6, 1, 218, 1), + FoldRange::from(0x1A7, 1, 1, 1), + FoldRange::from(0x1A9, 1, 218, 1), + FoldRange::from(0x1AC, 1, 1, 1), + FoldRange::from(0x1AE, 1, 218, 1), + FoldRange::from(0x1AF, 1, 1, 1), + FoldRange::from(0x1B1, 2, 217, 1), + FoldRange::from(0x1B3, 3, 1, 2), + FoldRange::from(0x1B7, 1, 219, 1), + FoldRange::from(0x1B8, 5, 1, 4), + FoldRange::from(0x1C4, 1, 2, 1), + FoldRange::from(0x1C5, 1, 1, 1), + FoldRange::from(0x1C7, 1, 2, 1), + FoldRange::from(0x1C8, 1, 1, 1), + FoldRange::from(0x1CA, 1, 2, 1), + FoldRange::from(0x1CB, 17, 1, 2), + FoldRange::from(0x1DE, 17, 1, 2), + FoldRange::from(0x1F1, 1, 2, 1), + FoldRange::from(0x1F2, 3, 1, 2), + FoldRange::from(0x1F6, 1, -97, 1), + FoldRange::from(0x1F7, 1, -56, 1), + FoldRange::from(0x1F8, 39, 1, 2), + FoldRange::from(0x220, 1, -130, 1), + FoldRange::from(0x222, 17, 1, 2), + FoldRange::from(0x23A, 1, 10795, 1), + FoldRange::from(0x23B, 1, 1, 1), + FoldRange::from(0x23D, 1, -163, 1), + FoldRange::from(0x23E, 1, 10792, 1), + FoldRange::from(0x241, 1, 1, 1), + FoldRange::from(0x243, 1, -195, 1), + FoldRange::from(0x244, 1, 69, 1), + FoldRange::from(0x245, 1, 71, 1), + FoldRange::from(0x246, 9, 1, 2), + FoldRange::from(0x345, 1, 116, 1), + FoldRange::from(0x370, 3, 1, 2), + FoldRange::from(0x376, 1, 1, 1), + FoldRange::from(0x37F, 1, 116, 1), + FoldRange::from(0x386, 1, 38, 1), + FoldRange::from(0x388, 3, 37, 1), + FoldRange::from(0x38C, 1, 64, 1), + FoldRange::from(0x38E, 2, 63, 1), + FoldRange::from(0x391, 17, 32, 1), + FoldRange::from(0x3A3, 9, 32, 1), + FoldRange::from(0x3C2, 1, 1, 1), + FoldRange::from(0x3CF, 1, 8, 1), + FoldRange::from(0x3D0, 1, -30, 1), + FoldRange::from(0x3D1, 1, -25, 1), + FoldRange::from(0x3D5, 1, -15, 1), + FoldRange::from(0x3D6, 1, -22, 1), + FoldRange::from(0x3D8, 23, 1, 2), + FoldRange::from(0x3F0, 1, -54, 1), + FoldRange::from(0x3F1, 1, -48, 1), + FoldRange::from(0x3F4, 1, -60, 1), + FoldRange::from(0x3F5, 1, -64, 1), + FoldRange::from(0x3F7, 1, 1, 1), + FoldRange::from(0x3F9, 1, -7, 1), + FoldRange::from(0x3FA, 1, 1, 1), + FoldRange::from(0x3FD, 3, -130, 1), + FoldRange::from(0x400, 16, 80, 1), + FoldRange::from(0x410, 32, 32, 1), + FoldRange::from(0x460, 33, 1, 2), + FoldRange::from(0x48A, 53, 1, 2), + FoldRange::from(0x4C0, 1, 15, 1), + FoldRange::from(0x4C1, 13, 1, 2), + FoldRange::from(0x4D0, 95, 1, 2), + FoldRange::from(0x531, 38, 48, 1), + FoldRange::from(0x10A0, 38, 7264, 1), + FoldRange::from(0x10C7, 1, 7264, 1), + FoldRange::from(0x10CD, 1, 7264, 1), + FoldRange::from(0x13F8, 6, -8, 1), + FoldRange::from(0x1C80, 1, -6222, 1), + FoldRange::from(0x1C81, 1, -6221, 1), + FoldRange::from(0x1C82, 1, -6212, 1), + FoldRange::from(0x1C83, 2, -6210, 1), + FoldRange::from(0x1C85, 1, -6211, 1), + FoldRange::from(0x1C86, 1, -6204, 1), + FoldRange::from(0x1C87, 1, -6180, 1), + FoldRange::from(0x1C88, 1, 35267, 1), + FoldRange::from(0x1C89, 1, 1, 1), + FoldRange::from(0x1C90, 43, -3008, 1), + FoldRange::from(0x1CBD, 3, -3008, 1), + FoldRange::from(0x1E00, 149, 1, 2), + FoldRange::from(0x1E9B, 1, -58, 1), + FoldRange::from(0x1E9E, 1, -7615, 1), + FoldRange::from(0x1EA0, 95, 1, 2), + FoldRange::from(0x1F08, 8, -8, 1), + FoldRange::from(0x1F18, 6, -8, 1), + FoldRange::from(0x1F28, 8, -8, 1), + FoldRange::from(0x1F38, 8, -8, 1), + FoldRange::from(0x1F48, 6, -8, 1), + FoldRange::from(0x1F59, 7, -8, 2), + FoldRange::from(0x1F68, 8, -8, 1), + FoldRange::from(0x1F88, 8, -8, 1), + FoldRange::from(0x1F98, 8, -8, 1), + FoldRange::from(0x1FA8, 8, -8, 1), + FoldRange::from(0x1FB8, 2, -8, 1), + FoldRange::from(0x1FBA, 2, -74, 1), + FoldRange::from(0x1FBC, 1, -9, 1), + FoldRange::from(0x1FBE, 1, -7173, 1), + FoldRange::from(0x1FC8, 4, -86, 1), + FoldRange::from(0x1FCC, 1, -9, 1), + FoldRange::from(0x1FD3, 1, -7235, 1), + FoldRange::from(0x1FD8, 2, -8, 1), + FoldRange::from(0x1FDA, 2, -100, 1), + FoldRange::from(0x1FE3, 1, -7219, 1), + FoldRange::from(0x1FE8, 2, -8, 1), + FoldRange::from(0x1FEA, 2, -112, 1), + FoldRange::from(0x1FEC, 1, -7, 1), + FoldRange::from(0x1FF8, 2, -128, 1), + FoldRange::from(0x1FFA, 2, -126, 1), + FoldRange::from(0x1FFC, 1, -9, 1), + FoldRange::from(0x2126, 1, -7517, 1), + FoldRange::from(0x212A, 1, -8383, 1), + FoldRange::from(0x212B, 1, -8262, 1), + FoldRange::from(0x2132, 1, 28, 1), + FoldRange::from(0x2160, 16, 16, 1), + FoldRange::from(0x2183, 1, 1, 1), + FoldRange::from(0x24B6, 26, 26, 1), + FoldRange::from(0x2C00, 48, 48, 1), + FoldRange::from(0x2C60, 1, 1, 1), + FoldRange::from(0x2C62, 1, -10743, 1), + FoldRange::from(0x2C63, 1, -3814, 1), + FoldRange::from(0x2C64, 1, -10727, 1), + FoldRange::from(0x2C67, 5, 1, 2), + FoldRange::from(0x2C6D, 1, -10780, 1), + FoldRange::from(0x2C6E, 1, -10749, 1), + FoldRange::from(0x2C6F, 1, -10783, 1), + FoldRange::from(0x2C70, 1, -10782, 1), + FoldRange::from(0x2C72, 1, 1, 1), + FoldRange::from(0x2C75, 1, 1, 1), + FoldRange::from(0x2C7E, 2, -10815, 1), + FoldRange::from(0x2C80, 99, 1, 2), + FoldRange::from(0x2CEB, 3, 1, 2), + FoldRange::from(0x2CF2, 1, 1, 1), + FoldRange::from(0xA640, 45, 1, 2), + FoldRange::from(0xA680, 27, 1, 2), + FoldRange::from(0xA722, 13, 1, 2), + FoldRange::from(0xA732, 61, 1, 2), + FoldRange::from(0xA779, 3, 1, 2), + FoldRange::from(0xA77D, 1, -35332, 1), + FoldRange::from(0xA77E, 9, 1, 2), + FoldRange::from(0xA78B, 1, 1, 1), + FoldRange::from(0xA78D, 1, -42280, 1), + FoldRange::from(0xA790, 3, 1, 2), + FoldRange::from(0xA796, 19, 1, 2), + FoldRange::from(0xA7AA, 1, -42308, 1), + FoldRange::from(0xA7AB, 1, -42319, 1), + FoldRange::from(0xA7AC, 1, -42315, 1), + FoldRange::from(0xA7AD, 1, -42305, 1), + FoldRange::from(0xA7AE, 1, -42308, 1), + FoldRange::from(0xA7B0, 1, -42258, 1), + FoldRange::from(0xA7B1, 1, -42282, 1), + FoldRange::from(0xA7B2, 1, -42261, 1), + FoldRange::from(0xA7B3, 1, 928, 1), + FoldRange::from(0xA7B4, 15, 1, 2), + FoldRange::from(0xA7C4, 1, -48, 1), + FoldRange::from(0xA7C5, 1, -42307, 1), + FoldRange::from(0xA7C6, 1, -35384, 1), + FoldRange::from(0xA7C7, 3, 1, 2), + FoldRange::from(0xA7CB, 1, -42343, 1), + FoldRange::from(0xA7CC, 15, 1, 2), + FoldRange::from(0xA7DC, 1, -42561, 1), + FoldRange::from(0xA7F5, 1, 1, 1), + FoldRange::from(0xAB70, 80, -38864, 1), + FoldRange::from(0xFB05, 1, 1, 1), + FoldRange::from(0xFF21, 26, 32, 1), + FoldRange::from(0x10400, 40, 40, 1), + FoldRange::from(0x104B0, 36, 40, 1), + FoldRange::from(0x10570, 11, 39, 1), + FoldRange::from(0x1057C, 15, 39, 1), + FoldRange::from(0x1058C, 7, 39, 1), + FoldRange::from(0x10594, 2, 39, 1), + FoldRange::from(0x10C80, 51, 64, 1), + FoldRange::from(0x10D50, 22, 32, 1), + FoldRange::from(0x118A0, 32, 32, 1), + FoldRange::from(0x16E40, 32, 32, 1), + FoldRange::from(0x16EA0, 25, 27, 1), + FoldRange::from(0x1E900, 34, 34, 1), +]; + +// \return whether a non-ASCII character folds to an ASCII word char. +#[inline] +pub(crate) fn nonascii_folds_to_ascii_word_char(cp: u32) -> bool { + match cp { + 0x017F => true, // folds to 's' + 0x212A => true, // folds to 'k' + _ => false, + } +} + +const CLOSE_PUNCTUATION: [Interval; 76] = [ + Interval::new(41, 41), + Interval::new(93, 93), + Interval::new(125, 125), + Interval::new(3899, 3899), + Interval::new(3901, 3901), + Interval::new(5788, 5788), + Interval::new(8262, 8262), + Interval::new(8318, 8318), + Interval::new(8334, 8334), + Interval::new(8969, 8969), + Interval::new(8971, 8971), + Interval::new(9002, 9002), + Interval::new(10089, 10089), + Interval::new(10091, 10091), + Interval::new(10093, 10093), + Interval::new(10095, 10095), + Interval::new(10097, 10097), + Interval::new(10099, 10099), + Interval::new(10101, 10101), + Interval::new(10182, 10182), + Interval::new(10215, 10215), + Interval::new(10217, 10217), + Interval::new(10219, 10219), + Interval::new(10221, 10221), + Interval::new(10223, 10223), + Interval::new(10628, 10628), + Interval::new(10630, 10630), + Interval::new(10632, 10632), + Interval::new(10634, 10634), + Interval::new(10636, 10636), + Interval::new(10638, 10638), + Interval::new(10640, 10640), + Interval::new(10642, 10642), + Interval::new(10644, 10644), + Interval::new(10646, 10646), + Interval::new(10648, 10648), + Interval::new(10713, 10713), + Interval::new(10715, 10715), + Interval::new(10749, 10749), + Interval::new(11811, 11811), + Interval::new(11813, 11813), + Interval::new(11815, 11815), + Interval::new(11817, 11817), + Interval::new(11862, 11862), + Interval::new(11864, 11864), + Interval::new(11866, 11866), + Interval::new(11868, 11868), + Interval::new(12297, 12297), + Interval::new(12299, 12299), + Interval::new(12301, 12301), + Interval::new(12303, 12303), + Interval::new(12305, 12305), + Interval::new(12309, 12309), + Interval::new(12311, 12311), + Interval::new(12313, 12313), + Interval::new(12315, 12315), + Interval::new(12318, 12319), + Interval::new(64830, 64830), + Interval::new(65048, 65048), + Interval::new(65078, 65078), + Interval::new(65080, 65080), + Interval::new(65082, 65082), + Interval::new(65084, 65084), + Interval::new(65086, 65086), + Interval::new(65088, 65088), + Interval::new(65090, 65090), + Interval::new(65092, 65092), + Interval::new(65096, 65096), + Interval::new(65114, 65114), + Interval::new(65116, 65116), + Interval::new(65118, 65118), + Interval::new(65289, 65289), + Interval::new(65341, 65341), + Interval::new(65373, 65373), + Interval::new(65376, 65376), + Interval::new(65379, 65379), +]; + +/// Return the code point ranges of the 'Close_Punctuation' Unicode property. +pub(crate) fn close_punctuation_ranges() -> &'static [Interval] { + &CLOSE_PUNCTUATION +} + +const CONNECTOR_PUNCTUATION: [Interval; 6] = [ + Interval::new(95, 95), + Interval::new(8255, 8256), + Interval::new(8276, 8276), + Interval::new(65075, 65076), + Interval::new(65101, 65103), + Interval::new(65343, 65343), +]; + +/// Return the code point ranges of the 'Connector_Punctuation' Unicode property. +pub(crate) fn connector_punctuation_ranges() -> &'static [Interval] { + &CONNECTOR_PUNCTUATION +} + +const CONTROL: [Interval; 2] = [Interval::new(0, 31), Interval::new(127, 159)]; + +/// Return the code point ranges of the 'Control' Unicode property. +pub(crate) fn control_ranges() -> &'static [Interval] { + &CONTROL +} + +const CURRENCY_SYMBOL: [Interval; 21] = [ + Interval::new(36, 36), + Interval::new(162, 165), + Interval::new(1423, 1423), + Interval::new(1547, 1547), + Interval::new(2046, 2047), + Interval::new(2546, 2547), + Interval::new(2555, 2555), + Interval::new(2801, 2801), + Interval::new(3065, 3065), + Interval::new(3647, 3647), + Interval::new(6107, 6107), + Interval::new(8352, 8385), + Interval::new(43064, 43064), + Interval::new(65020, 65020), + Interval::new(65129, 65129), + Interval::new(65284, 65284), + Interval::new(65504, 65505), + Interval::new(65509, 65510), + Interval::new(73693, 73696), + Interval::new(123647, 123647), + Interval::new(126128, 126128), +]; + +/// Return the code point ranges of the 'Currency_Symbol' Unicode property. +pub(crate) fn currency_symbol_ranges() -> &'static [Interval] { + &CURRENCY_SYMBOL +} + +const DASH_PUNCTUATION: [Interval; 20] = [ + Interval::new(45, 45), + Interval::new(1418, 1418), + Interval::new(1470, 1470), + Interval::new(5120, 5120), + Interval::new(6150, 6150), + Interval::new(8208, 8213), + Interval::new(11799, 11799), + Interval::new(11802, 11802), + Interval::new(11834, 11835), + Interval::new(11840, 11840), + Interval::new(11869, 11869), + Interval::new(12316, 12316), + Interval::new(12336, 12336), + Interval::new(12448, 12448), + Interval::new(65073, 65074), + Interval::new(65112, 65112), + Interval::new(65123, 65123), + Interval::new(65293, 65293), + Interval::new(68974, 68974), + Interval::new(69293, 69293), +]; + +/// Return the code point ranges of the 'Dash_Punctuation' Unicode property. +pub(crate) fn dash_punctuation_ranges() -> &'static [Interval] { + &DASH_PUNCTUATION +} + +const DECIMAL_NUMBER: [Interval; 72] = [ + Interval::new(48, 57), + Interval::new(1632, 1641), + Interval::new(1776, 1785), + Interval::new(1984, 1993), + Interval::new(2406, 2415), + Interval::new(2534, 2543), + Interval::new(2662, 2671), + Interval::new(2790, 2799), + Interval::new(2918, 2927), + Interval::new(3046, 3055), + Interval::new(3174, 3183), + Interval::new(3302, 3311), + Interval::new(3430, 3439), + Interval::new(3558, 3567), + Interval::new(3664, 3673), + Interval::new(3792, 3801), + Interval::new(3872, 3881), + Interval::new(4160, 4169), + Interval::new(4240, 4249), + Interval::new(6112, 6121), + Interval::new(6160, 6169), + Interval::new(6470, 6479), + Interval::new(6608, 6617), + Interval::new(6784, 6793), + Interval::new(6800, 6809), + Interval::new(6992, 7001), + Interval::new(7088, 7097), + Interval::new(7232, 7241), + Interval::new(7248, 7257), + Interval::new(42528, 42537), + Interval::new(43216, 43225), + Interval::new(43264, 43273), + Interval::new(43472, 43481), + Interval::new(43504, 43513), + Interval::new(43600, 43609), + Interval::new(44016, 44025), + Interval::new(65296, 65305), + Interval::new(66720, 66729), + Interval::new(68912, 68921), + Interval::new(68928, 68937), + Interval::new(69734, 69743), + Interval::new(69872, 69881), + Interval::new(69942, 69951), + Interval::new(70096, 70105), + Interval::new(70384, 70393), + Interval::new(70736, 70745), + Interval::new(70864, 70873), + Interval::new(71248, 71257), + Interval::new(71360, 71369), + Interval::new(71376, 71395), + Interval::new(71472, 71481), + Interval::new(71904, 71913), + Interval::new(72016, 72025), + Interval::new(72688, 72697), + Interval::new(72784, 72793), + Interval::new(73040, 73049), + Interval::new(73120, 73129), + Interval::new(73184, 73193), + Interval::new(73552, 73561), + Interval::new(90416, 90425), + Interval::new(92768, 92777), + Interval::new(92864, 92873), + Interval::new(93008, 93017), + Interval::new(93552, 93561), + Interval::new(118000, 118009), + Interval::new(120782, 120831), + Interval::new(123200, 123209), + Interval::new(123632, 123641), + Interval::new(124144, 124153), + Interval::new(124401, 124410), + Interval::new(125264, 125273), + Interval::new(130032, 130041), +]; + +/// Return the code point ranges of the 'Decimal_Number' Unicode property. +pub(crate) fn decimal_number_ranges() -> &'static [Interval] { + &DECIMAL_NUMBER +} + +const ENCLOSING_MARK: [Interval; 5] = [ + Interval::new(1160, 1161), + Interval::new(6846, 6846), + Interval::new(8413, 8416), + Interval::new(8418, 8420), + Interval::new(42608, 42610), +]; + +/// Return the code point ranges of the 'Enclosing_Mark' Unicode property. +pub(crate) fn enclosing_mark_ranges() -> &'static [Interval] { + &ENCLOSING_MARK +} + +const FINAL_PUNCTUATION: [Interval; 10] = [ + Interval::new(187, 187), + Interval::new(8217, 8217), + Interval::new(8221, 8221), + Interval::new(8250, 8250), + Interval::new(11779, 11779), + Interval::new(11781, 11781), + Interval::new(11786, 11786), + Interval::new(11789, 11789), + Interval::new(11805, 11805), + Interval::new(11809, 11809), +]; + +/// Return the code point ranges of the 'Final_Punctuation' Unicode property. +pub(crate) fn final_punctuation_ranges() -> &'static [Interval] { + &FINAL_PUNCTUATION +} + +const FORMAT: [Interval; 21] = [ + Interval::new(173, 173), + Interval::new(1536, 1541), + Interval::new(1564, 1564), + Interval::new(1757, 1757), + Interval::new(1807, 1807), + Interval::new(2192, 2193), + Interval::new(2274, 2274), + Interval::new(6158, 6158), + Interval::new(8203, 8207), + Interval::new(8234, 8238), + Interval::new(8288, 8292), + Interval::new(8294, 8303), + Interval::new(65279, 65279), + Interval::new(65529, 65531), + Interval::new(69821, 69821), + Interval::new(69837, 69837), + Interval::new(78896, 78911), + Interval::new(113824, 113827), + Interval::new(119155, 119162), + Interval::new(917505, 917505), + Interval::new(917536, 917631), +]; + +/// Return the code point ranges of the 'Format' Unicode property. +pub(crate) fn format_ranges() -> &'static [Interval] { + &FORMAT +} + +const INITIAL_PUNCTUATION: [Interval; 11] = [ + Interval::new(171, 171), + Interval::new(8216, 8216), + Interval::new(8219, 8220), + Interval::new(8223, 8223), + Interval::new(8249, 8249), + Interval::new(11778, 11778), + Interval::new(11780, 11780), + Interval::new(11785, 11785), + Interval::new(11788, 11788), + Interval::new(11804, 11804), + Interval::new(11808, 11808), +]; + +/// Return the code point ranges of the 'Initial_Punctuation' Unicode property. +pub(crate) fn initial_punctuation_ranges() -> &'static [Interval] { + &INITIAL_PUNCTUATION +} + +const LETTER_NUMBER: [Interval; 13] = [ + Interval::new(5870, 5872), + Interval::new(8544, 8578), + Interval::new(8581, 8584), + Interval::new(12295, 12295), + Interval::new(12321, 12329), + Interval::new(12344, 12346), + Interval::new(42726, 42735), + Interval::new(65856, 65908), + Interval::new(66369, 66369), + Interval::new(66378, 66378), + Interval::new(66513, 66517), + Interval::new(74752, 74862), + Interval::new(94196, 94198), +]; + +/// Return the code point ranges of the 'Letter_Number' Unicode property. +pub(crate) fn letter_number_ranges() -> &'static [Interval] { + &LETTER_NUMBER +} + +const LINE_SEPARATOR: [Interval; 1] = [Interval::new(8232, 8232)]; + +/// Return the code point ranges of the 'Line_Separator' Unicode property. +pub(crate) fn line_separator_ranges() -> &'static [Interval] { + &LINE_SEPARATOR +} + +const LOWERCASE_LETTER: [Interval; 664] = [ + Interval::new(97, 122), + Interval::new(181, 181), + Interval::new(223, 246), + Interval::new(248, 255), + Interval::new(257, 257), + Interval::new(259, 259), + Interval::new(261, 261), + Interval::new(263, 263), + Interval::new(265, 265), + Interval::new(267, 267), + Interval::new(269, 269), + Interval::new(271, 271), + Interval::new(273, 273), + Interval::new(275, 275), + Interval::new(277, 277), + Interval::new(279, 279), + Interval::new(281, 281), + Interval::new(283, 283), + Interval::new(285, 285), + Interval::new(287, 287), + Interval::new(289, 289), + Interval::new(291, 291), + Interval::new(293, 293), + Interval::new(295, 295), + Interval::new(297, 297), + Interval::new(299, 299), + Interval::new(301, 301), + Interval::new(303, 303), + Interval::new(305, 305), + Interval::new(307, 307), + Interval::new(309, 309), + Interval::new(311, 312), + Interval::new(314, 314), + Interval::new(316, 316), + Interval::new(318, 318), + Interval::new(320, 320), + Interval::new(322, 322), + Interval::new(324, 324), + Interval::new(326, 326), + Interval::new(328, 329), + Interval::new(331, 331), + Interval::new(333, 333), + Interval::new(335, 335), + Interval::new(337, 337), + Interval::new(339, 339), + Interval::new(341, 341), + Interval::new(343, 343), + Interval::new(345, 345), + Interval::new(347, 347), + Interval::new(349, 349), + Interval::new(351, 351), + Interval::new(353, 353), + Interval::new(355, 355), + Interval::new(357, 357), + Interval::new(359, 359), + Interval::new(361, 361), + Interval::new(363, 363), + Interval::new(365, 365), + Interval::new(367, 367), + Interval::new(369, 369), + Interval::new(371, 371), + Interval::new(373, 373), + Interval::new(375, 375), + Interval::new(378, 378), + Interval::new(380, 380), + Interval::new(382, 384), + Interval::new(387, 387), + Interval::new(389, 389), + Interval::new(392, 392), + Interval::new(396, 397), + Interval::new(402, 402), + Interval::new(405, 405), + Interval::new(409, 411), + Interval::new(414, 414), + Interval::new(417, 417), + Interval::new(419, 419), + Interval::new(421, 421), + Interval::new(424, 424), + Interval::new(426, 427), + Interval::new(429, 429), + Interval::new(432, 432), + Interval::new(436, 436), + Interval::new(438, 438), + Interval::new(441, 442), + Interval::new(445, 447), + Interval::new(454, 454), + Interval::new(457, 457), + Interval::new(460, 460), + Interval::new(462, 462), + Interval::new(464, 464), + Interval::new(466, 466), + Interval::new(468, 468), + Interval::new(470, 470), + Interval::new(472, 472), + Interval::new(474, 474), + Interval::new(476, 477), + Interval::new(479, 479), + Interval::new(481, 481), + Interval::new(483, 483), + Interval::new(485, 485), + Interval::new(487, 487), + Interval::new(489, 489), + Interval::new(491, 491), + Interval::new(493, 493), + Interval::new(495, 496), + Interval::new(499, 499), + Interval::new(501, 501), + Interval::new(505, 505), + Interval::new(507, 507), + Interval::new(509, 509), + Interval::new(511, 511), + Interval::new(513, 513), + Interval::new(515, 515), + Interval::new(517, 517), + Interval::new(519, 519), + Interval::new(521, 521), + Interval::new(523, 523), + Interval::new(525, 525), + Interval::new(527, 527), + Interval::new(529, 529), + Interval::new(531, 531), + Interval::new(533, 533), + Interval::new(535, 535), + Interval::new(537, 537), + Interval::new(539, 539), + Interval::new(541, 541), + Interval::new(543, 543), + Interval::new(545, 545), + Interval::new(547, 547), + Interval::new(549, 549), + Interval::new(551, 551), + Interval::new(553, 553), + Interval::new(555, 555), + Interval::new(557, 557), + Interval::new(559, 559), + Interval::new(561, 561), + Interval::new(563, 569), + Interval::new(572, 572), + Interval::new(575, 576), + Interval::new(578, 578), + Interval::new(583, 583), + Interval::new(585, 585), + Interval::new(587, 587), + Interval::new(589, 589), + Interval::new(591, 659), + Interval::new(662, 687), + Interval::new(881, 881), + Interval::new(883, 883), + Interval::new(887, 887), + Interval::new(891, 893), + Interval::new(912, 912), + Interval::new(940, 974), + Interval::new(976, 977), + Interval::new(981, 983), + Interval::new(985, 985), + Interval::new(987, 987), + Interval::new(989, 989), + Interval::new(991, 991), + Interval::new(993, 993), + Interval::new(995, 995), + Interval::new(997, 997), + Interval::new(999, 999), + Interval::new(1001, 1001), + Interval::new(1003, 1003), + Interval::new(1005, 1005), + Interval::new(1007, 1011), + Interval::new(1013, 1013), + Interval::new(1016, 1016), + Interval::new(1019, 1020), + Interval::new(1072, 1119), + Interval::new(1121, 1121), + Interval::new(1123, 1123), + Interval::new(1125, 1125), + Interval::new(1127, 1127), + Interval::new(1129, 1129), + Interval::new(1131, 1131), + Interval::new(1133, 1133), + Interval::new(1135, 1135), + Interval::new(1137, 1137), + Interval::new(1139, 1139), + Interval::new(1141, 1141), + Interval::new(1143, 1143), + Interval::new(1145, 1145), + Interval::new(1147, 1147), + Interval::new(1149, 1149), + Interval::new(1151, 1151), + Interval::new(1153, 1153), + Interval::new(1163, 1163), + Interval::new(1165, 1165), + Interval::new(1167, 1167), + Interval::new(1169, 1169), + Interval::new(1171, 1171), + Interval::new(1173, 1173), + Interval::new(1175, 1175), + Interval::new(1177, 1177), + Interval::new(1179, 1179), + Interval::new(1181, 1181), + Interval::new(1183, 1183), + Interval::new(1185, 1185), + Interval::new(1187, 1187), + Interval::new(1189, 1189), + Interval::new(1191, 1191), + Interval::new(1193, 1193), + Interval::new(1195, 1195), + Interval::new(1197, 1197), + Interval::new(1199, 1199), + Interval::new(1201, 1201), + Interval::new(1203, 1203), + Interval::new(1205, 1205), + Interval::new(1207, 1207), + Interval::new(1209, 1209), + Interval::new(1211, 1211), + Interval::new(1213, 1213), + Interval::new(1215, 1215), + Interval::new(1218, 1218), + Interval::new(1220, 1220), + Interval::new(1222, 1222), + Interval::new(1224, 1224), + Interval::new(1226, 1226), + Interval::new(1228, 1228), + Interval::new(1230, 1231), + Interval::new(1233, 1233), + Interval::new(1235, 1235), + Interval::new(1237, 1237), + Interval::new(1239, 1239), + Interval::new(1241, 1241), + Interval::new(1243, 1243), + Interval::new(1245, 1245), + Interval::new(1247, 1247), + Interval::new(1249, 1249), + Interval::new(1251, 1251), + Interval::new(1253, 1253), + Interval::new(1255, 1255), + Interval::new(1257, 1257), + Interval::new(1259, 1259), + Interval::new(1261, 1261), + Interval::new(1263, 1263), + Interval::new(1265, 1265), + Interval::new(1267, 1267), + Interval::new(1269, 1269), + Interval::new(1271, 1271), + Interval::new(1273, 1273), + Interval::new(1275, 1275), + Interval::new(1277, 1277), + Interval::new(1279, 1279), + Interval::new(1281, 1281), + Interval::new(1283, 1283), + Interval::new(1285, 1285), + Interval::new(1287, 1287), + Interval::new(1289, 1289), + Interval::new(1291, 1291), + Interval::new(1293, 1293), + Interval::new(1295, 1295), + Interval::new(1297, 1297), + Interval::new(1299, 1299), + Interval::new(1301, 1301), + Interval::new(1303, 1303), + Interval::new(1305, 1305), + Interval::new(1307, 1307), + Interval::new(1309, 1309), + Interval::new(1311, 1311), + Interval::new(1313, 1313), + Interval::new(1315, 1315), + Interval::new(1317, 1317), + Interval::new(1319, 1319), + Interval::new(1321, 1321), + Interval::new(1323, 1323), + Interval::new(1325, 1325), + Interval::new(1327, 1327), + Interval::new(1376, 1416), + Interval::new(4304, 4346), + Interval::new(4349, 4351), + Interval::new(5112, 5117), + Interval::new(7296, 7304), + Interval::new(7306, 7306), + Interval::new(7424, 7467), + Interval::new(7531, 7543), + Interval::new(7545, 7578), + Interval::new(7681, 7681), + Interval::new(7683, 7683), + Interval::new(7685, 7685), + Interval::new(7687, 7687), + Interval::new(7689, 7689), + Interval::new(7691, 7691), + Interval::new(7693, 7693), + Interval::new(7695, 7695), + Interval::new(7697, 7697), + Interval::new(7699, 7699), + Interval::new(7701, 7701), + Interval::new(7703, 7703), + Interval::new(7705, 7705), + Interval::new(7707, 7707), + Interval::new(7709, 7709), + Interval::new(7711, 7711), + Interval::new(7713, 7713), + Interval::new(7715, 7715), + Interval::new(7717, 7717), + Interval::new(7719, 7719), + Interval::new(7721, 7721), + Interval::new(7723, 7723), + Interval::new(7725, 7725), + Interval::new(7727, 7727), + Interval::new(7729, 7729), + Interval::new(7731, 7731), + Interval::new(7733, 7733), + Interval::new(7735, 7735), + Interval::new(7737, 7737), + Interval::new(7739, 7739), + Interval::new(7741, 7741), + Interval::new(7743, 7743), + Interval::new(7745, 7745), + Interval::new(7747, 7747), + Interval::new(7749, 7749), + Interval::new(7751, 7751), + Interval::new(7753, 7753), + Interval::new(7755, 7755), + Interval::new(7757, 7757), + Interval::new(7759, 7759), + Interval::new(7761, 7761), + Interval::new(7763, 7763), + Interval::new(7765, 7765), + Interval::new(7767, 7767), + Interval::new(7769, 7769), + Interval::new(7771, 7771), + Interval::new(7773, 7773), + Interval::new(7775, 7775), + Interval::new(7777, 7777), + Interval::new(7779, 7779), + Interval::new(7781, 7781), + Interval::new(7783, 7783), + Interval::new(7785, 7785), + Interval::new(7787, 7787), + Interval::new(7789, 7789), + Interval::new(7791, 7791), + Interval::new(7793, 7793), + Interval::new(7795, 7795), + Interval::new(7797, 7797), + Interval::new(7799, 7799), + Interval::new(7801, 7801), + Interval::new(7803, 7803), + Interval::new(7805, 7805), + Interval::new(7807, 7807), + Interval::new(7809, 7809), + Interval::new(7811, 7811), + Interval::new(7813, 7813), + Interval::new(7815, 7815), + Interval::new(7817, 7817), + Interval::new(7819, 7819), + Interval::new(7821, 7821), + Interval::new(7823, 7823), + Interval::new(7825, 7825), + Interval::new(7827, 7827), + Interval::new(7829, 7837), + Interval::new(7839, 7839), + Interval::new(7841, 7841), + Interval::new(7843, 7843), + Interval::new(7845, 7845), + Interval::new(7847, 7847), + Interval::new(7849, 7849), + Interval::new(7851, 7851), + Interval::new(7853, 7853), + Interval::new(7855, 7855), + Interval::new(7857, 7857), + Interval::new(7859, 7859), + Interval::new(7861, 7861), + Interval::new(7863, 7863), + Interval::new(7865, 7865), + Interval::new(7867, 7867), + Interval::new(7869, 7869), + Interval::new(7871, 7871), + Interval::new(7873, 7873), + Interval::new(7875, 7875), + Interval::new(7877, 7877), + Interval::new(7879, 7879), + Interval::new(7881, 7881), + Interval::new(7883, 7883), + Interval::new(7885, 7885), + Interval::new(7887, 7887), + Interval::new(7889, 7889), + Interval::new(7891, 7891), + Interval::new(7893, 7893), + Interval::new(7895, 7895), + Interval::new(7897, 7897), + Interval::new(7899, 7899), + Interval::new(7901, 7901), + Interval::new(7903, 7903), + Interval::new(7905, 7905), + Interval::new(7907, 7907), + Interval::new(7909, 7909), + Interval::new(7911, 7911), + Interval::new(7913, 7913), + Interval::new(7915, 7915), + Interval::new(7917, 7917), + Interval::new(7919, 7919), + Interval::new(7921, 7921), + Interval::new(7923, 7923), + Interval::new(7925, 7925), + Interval::new(7927, 7927), + Interval::new(7929, 7929), + Interval::new(7931, 7931), + Interval::new(7933, 7933), + Interval::new(7935, 7943), + Interval::new(7952, 7957), + Interval::new(7968, 7975), + Interval::new(7984, 7991), + Interval::new(8000, 8005), + Interval::new(8016, 8023), + Interval::new(8032, 8039), + Interval::new(8048, 8061), + Interval::new(8064, 8071), + Interval::new(8080, 8087), + Interval::new(8096, 8103), + Interval::new(8112, 8116), + Interval::new(8118, 8119), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8135), + Interval::new(8144, 8147), + Interval::new(8150, 8151), + Interval::new(8160, 8167), + Interval::new(8178, 8180), + Interval::new(8182, 8183), + Interval::new(8458, 8458), + Interval::new(8462, 8463), + Interval::new(8467, 8467), + Interval::new(8495, 8495), + Interval::new(8500, 8500), + Interval::new(8505, 8505), + Interval::new(8508, 8509), + Interval::new(8518, 8521), + Interval::new(8526, 8526), + Interval::new(8580, 8580), + Interval::new(11312, 11359), + Interval::new(11361, 11361), + Interval::new(11365, 11366), + Interval::new(11368, 11368), + Interval::new(11370, 11370), + Interval::new(11372, 11372), + Interval::new(11377, 11377), + Interval::new(11379, 11380), + Interval::new(11382, 11387), + Interval::new(11393, 11393), + Interval::new(11395, 11395), + Interval::new(11397, 11397), + Interval::new(11399, 11399), + Interval::new(11401, 11401), + Interval::new(11403, 11403), + Interval::new(11405, 11405), + Interval::new(11407, 11407), + Interval::new(11409, 11409), + Interval::new(11411, 11411), + Interval::new(11413, 11413), + Interval::new(11415, 11415), + Interval::new(11417, 11417), + Interval::new(11419, 11419), + Interval::new(11421, 11421), + Interval::new(11423, 11423), + Interval::new(11425, 11425), + Interval::new(11427, 11427), + Interval::new(11429, 11429), + Interval::new(11431, 11431), + Interval::new(11433, 11433), + Interval::new(11435, 11435), + Interval::new(11437, 11437), + Interval::new(11439, 11439), + Interval::new(11441, 11441), + Interval::new(11443, 11443), + Interval::new(11445, 11445), + Interval::new(11447, 11447), + Interval::new(11449, 11449), + Interval::new(11451, 11451), + Interval::new(11453, 11453), + Interval::new(11455, 11455), + Interval::new(11457, 11457), + Interval::new(11459, 11459), + Interval::new(11461, 11461), + Interval::new(11463, 11463), + Interval::new(11465, 11465), + Interval::new(11467, 11467), + Interval::new(11469, 11469), + Interval::new(11471, 11471), + Interval::new(11473, 11473), + Interval::new(11475, 11475), + Interval::new(11477, 11477), + Interval::new(11479, 11479), + Interval::new(11481, 11481), + Interval::new(11483, 11483), + Interval::new(11485, 11485), + Interval::new(11487, 11487), + Interval::new(11489, 11489), + Interval::new(11491, 11492), + Interval::new(11500, 11500), + Interval::new(11502, 11502), + Interval::new(11507, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42561, 42561), + Interval::new(42563, 42563), + Interval::new(42565, 42565), + Interval::new(42567, 42567), + Interval::new(42569, 42569), + Interval::new(42571, 42571), + Interval::new(42573, 42573), + Interval::new(42575, 42575), + Interval::new(42577, 42577), + Interval::new(42579, 42579), + Interval::new(42581, 42581), + Interval::new(42583, 42583), + Interval::new(42585, 42585), + Interval::new(42587, 42587), + Interval::new(42589, 42589), + Interval::new(42591, 42591), + Interval::new(42593, 42593), + Interval::new(42595, 42595), + Interval::new(42597, 42597), + Interval::new(42599, 42599), + Interval::new(42601, 42601), + Interval::new(42603, 42603), + Interval::new(42605, 42605), + Interval::new(42625, 42625), + Interval::new(42627, 42627), + Interval::new(42629, 42629), + Interval::new(42631, 42631), + Interval::new(42633, 42633), + Interval::new(42635, 42635), + Interval::new(42637, 42637), + Interval::new(42639, 42639), + Interval::new(42641, 42641), + Interval::new(42643, 42643), + Interval::new(42645, 42645), + Interval::new(42647, 42647), + Interval::new(42649, 42649), + Interval::new(42651, 42651), + Interval::new(42787, 42787), + Interval::new(42789, 42789), + Interval::new(42791, 42791), + Interval::new(42793, 42793), + Interval::new(42795, 42795), + Interval::new(42797, 42797), + Interval::new(42799, 42801), + Interval::new(42803, 42803), + Interval::new(42805, 42805), + Interval::new(42807, 42807), + Interval::new(42809, 42809), + Interval::new(42811, 42811), + Interval::new(42813, 42813), + Interval::new(42815, 42815), + Interval::new(42817, 42817), + Interval::new(42819, 42819), + Interval::new(42821, 42821), + Interval::new(42823, 42823), + Interval::new(42825, 42825), + Interval::new(42827, 42827), + Interval::new(42829, 42829), + Interval::new(42831, 42831), + Interval::new(42833, 42833), + Interval::new(42835, 42835), + Interval::new(42837, 42837), + Interval::new(42839, 42839), + Interval::new(42841, 42841), + Interval::new(42843, 42843), + Interval::new(42845, 42845), + Interval::new(42847, 42847), + Interval::new(42849, 42849), + Interval::new(42851, 42851), + Interval::new(42853, 42853), + Interval::new(42855, 42855), + Interval::new(42857, 42857), + Interval::new(42859, 42859), + Interval::new(42861, 42861), + Interval::new(42863, 42863), + Interval::new(42865, 42872), + Interval::new(42874, 42874), + Interval::new(42876, 42876), + Interval::new(42879, 42879), + Interval::new(42881, 42881), + Interval::new(42883, 42883), + Interval::new(42885, 42885), + Interval::new(42887, 42887), + Interval::new(42892, 42892), + Interval::new(42894, 42894), + Interval::new(42897, 42897), + Interval::new(42899, 42901), + Interval::new(42903, 42903), + Interval::new(42905, 42905), + Interval::new(42907, 42907), + Interval::new(42909, 42909), + Interval::new(42911, 42911), + Interval::new(42913, 42913), + Interval::new(42915, 42915), + Interval::new(42917, 42917), + Interval::new(42919, 42919), + Interval::new(42921, 42921), + Interval::new(42927, 42927), + Interval::new(42933, 42933), + Interval::new(42935, 42935), + Interval::new(42937, 42937), + Interval::new(42939, 42939), + Interval::new(42941, 42941), + Interval::new(42943, 42943), + Interval::new(42945, 42945), + Interval::new(42947, 42947), + Interval::new(42952, 42952), + Interval::new(42954, 42954), + Interval::new(42957, 42957), + Interval::new(42959, 42959), + Interval::new(42961, 42961), + Interval::new(42963, 42963), + Interval::new(42965, 42965), + Interval::new(42967, 42967), + Interval::new(42969, 42969), + Interval::new(42971, 42971), + Interval::new(42998, 42998), + Interval::new(43002, 43002), + Interval::new(43824, 43866), + Interval::new(43872, 43880), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65345, 65370), + Interval::new(66600, 66639), + Interval::new(66776, 66811), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(68800, 68850), + Interval::new(68976, 68997), + Interval::new(71872, 71903), + Interval::new(93792, 93823), + Interval::new(93883, 93907), + Interval::new(119834, 119859), + Interval::new(119886, 119892), + Interval::new(119894, 119911), + Interval::new(119938, 119963), + Interval::new(119990, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120015), + Interval::new(120042, 120067), + Interval::new(120094, 120119), + Interval::new(120146, 120171), + Interval::new(120198, 120223), + Interval::new(120250, 120275), + Interval::new(120302, 120327), + Interval::new(120354, 120379), + Interval::new(120406, 120431), + Interval::new(120458, 120485), + Interval::new(120514, 120538), + Interval::new(120540, 120545), + Interval::new(120572, 120596), + Interval::new(120598, 120603), + Interval::new(120630, 120654), + Interval::new(120656, 120661), + Interval::new(120688, 120712), + Interval::new(120714, 120719), + Interval::new(120746, 120770), + Interval::new(120772, 120777), + Interval::new(120779, 120779), + Interval::new(122624, 122633), + Interval::new(122635, 122654), + Interval::new(122661, 122666), + Interval::new(125218, 125251), +]; + +/// Return the code point ranges of the 'Lowercase_Letter' Unicode property. +pub(crate) fn lowercase_letter_ranges() -> &'static [Interval] { + &LOWERCASE_LETTER +} + +const MATH_SYMBOL: [Interval; 67] = [ + Interval::new(43, 43), + Interval::new(60, 62), + Interval::new(124, 124), + Interval::new(126, 126), + Interval::new(172, 172), + Interval::new(177, 177), + Interval::new(215, 215), + Interval::new(247, 247), + Interval::new(1014, 1014), + Interval::new(1542, 1544), + Interval::new(8260, 8260), + Interval::new(8274, 8274), + Interval::new(8314, 8316), + Interval::new(8330, 8332), + Interval::new(8472, 8472), + Interval::new(8512, 8516), + Interval::new(8523, 8523), + Interval::new(8592, 8596), + Interval::new(8602, 8603), + Interval::new(8608, 8608), + Interval::new(8611, 8611), + Interval::new(8614, 8614), + Interval::new(8622, 8622), + Interval::new(8654, 8655), + Interval::new(8658, 8658), + Interval::new(8660, 8660), + Interval::new(8692, 8959), + Interval::new(8992, 8993), + Interval::new(9084, 9084), + Interval::new(9115, 9139), + Interval::new(9180, 9185), + Interval::new(9655, 9655), + Interval::new(9665, 9665), + Interval::new(9720, 9727), + Interval::new(9839, 9839), + Interval::new(10176, 10180), + Interval::new(10183, 10213), + Interval::new(10224, 10239), + Interval::new(10496, 10626), + Interval::new(10649, 10711), + Interval::new(10716, 10747), + Interval::new(10750, 11007), + Interval::new(11056, 11076), + Interval::new(11079, 11084), + Interval::new(64297, 64297), + Interval::new(65122, 65122), + Interval::new(65124, 65126), + Interval::new(65291, 65291), + Interval::new(65308, 65310), + Interval::new(65372, 65372), + Interval::new(65374, 65374), + Interval::new(65506, 65506), + Interval::new(65513, 65516), + Interval::new(69006, 69007), + Interval::new(118512, 118512), + Interval::new(120513, 120513), + Interval::new(120539, 120539), + Interval::new(120571, 120571), + Interval::new(120597, 120597), + Interval::new(120629, 120629), + Interval::new(120655, 120655), + Interval::new(120687, 120687), + Interval::new(120713, 120713), + Interval::new(120745, 120745), + Interval::new(120771, 120771), + Interval::new(126704, 126705), + Interval::new(129232, 129240), +]; + +/// Return the code point ranges of the 'Math_Symbol' Unicode property. +pub(crate) fn math_symbol_ranges() -> &'static [Interval] { + &MATH_SYMBOL +} + +const MODIFIER_LETTER: [Interval; 79] = [ + Interval::new(688, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(884, 884), + Interval::new(890, 890), + Interval::new(1369, 1369), + Interval::new(1600, 1600), + Interval::new(1765, 1766), + Interval::new(2036, 2037), + Interval::new(2042, 2042), + Interval::new(2074, 2074), + Interval::new(2084, 2084), + Interval::new(2088, 2088), + Interval::new(2249, 2249), + Interval::new(2417, 2417), + Interval::new(3654, 3654), + Interval::new(3782, 3782), + Interval::new(4348, 4348), + Interval::new(6103, 6103), + Interval::new(6211, 6211), + Interval::new(6823, 6823), + Interval::new(7288, 7293), + Interval::new(7468, 7530), + Interval::new(7544, 7544), + Interval::new(7579, 7615), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(11388, 11389), + Interval::new(11631, 11631), + Interval::new(11823, 11823), + Interval::new(12293, 12293), + Interval::new(12337, 12341), + Interval::new(12347, 12347), + Interval::new(12445, 12446), + Interval::new(12540, 12542), + Interval::new(40981, 40981), + Interval::new(42232, 42237), + Interval::new(42508, 42508), + Interval::new(42623, 42623), + Interval::new(42652, 42653), + Interval::new(42775, 42783), + Interval::new(42864, 42864), + Interval::new(42888, 42888), + Interval::new(42993, 42996), + Interval::new(43000, 43001), + Interval::new(43471, 43471), + Interval::new(43494, 43494), + Interval::new(43632, 43632), + Interval::new(43741, 43741), + Interval::new(43763, 43764), + Interval::new(43868, 43871), + Interval::new(43881, 43881), + Interval::new(65392, 65392), + Interval::new(65438, 65439), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(68942, 68942), + Interval::new(68975, 68975), + Interval::new(69317, 69317), + Interval::new(73177, 73177), + Interval::new(92992, 92995), + Interval::new(93504, 93506), + Interval::new(93547, 93548), + Interval::new(94099, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94179), + Interval::new(94194, 94195), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(122928, 122989), + Interval::new(123191, 123197), + Interval::new(124139, 124139), + Interval::new(124671, 124671), + Interval::new(125259, 125259), +]; + +/// Return the code point ranges of the 'Modifier_Letter' Unicode property. +pub(crate) fn modifier_letter_ranges() -> &'static [Interval] { + &MODIFIER_LETTER +} + +const MODIFIER_SYMBOL: [Interval; 31] = [ + Interval::new(94, 94), + Interval::new(96, 96), + Interval::new(168, 168), + Interval::new(175, 175), + Interval::new(180, 180), + Interval::new(184, 184), + Interval::new(706, 709), + Interval::new(722, 735), + Interval::new(741, 747), + Interval::new(749, 749), + Interval::new(751, 767), + Interval::new(885, 885), + Interval::new(900, 901), + Interval::new(2184, 2184), + Interval::new(8125, 8125), + Interval::new(8127, 8129), + Interval::new(8141, 8143), + Interval::new(8157, 8159), + Interval::new(8173, 8175), + Interval::new(8189, 8190), + Interval::new(12443, 12444), + Interval::new(42752, 42774), + Interval::new(42784, 42785), + Interval::new(42889, 42890), + Interval::new(43867, 43867), + Interval::new(43882, 43883), + Interval::new(64434, 64450), + Interval::new(65342, 65342), + Interval::new(65344, 65344), + Interval::new(65507, 65507), + Interval::new(127995, 127999), +]; + +/// Return the code point ranges of the 'Modifier_Symbol' Unicode property. +pub(crate) fn modifier_symbol_ranges() -> &'static [Interval] { + &MODIFIER_SYMBOL +} + +const NONSPACING_MARK: [Interval; 365] = [ + Interval::new(768, 879), + Interval::new(1155, 1159), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1552, 1562), + Interval::new(1611, 1631), + Interval::new(1648, 1648), + Interval::new(1750, 1756), + Interval::new(1759, 1764), + Interval::new(1767, 1768), + Interval::new(1770, 1773), + Interval::new(1809, 1809), + Interval::new(1840, 1866), + Interval::new(1958, 1968), + Interval::new(2027, 2035), + Interval::new(2045, 2045), + Interval::new(2070, 2073), + Interval::new(2075, 2083), + Interval::new(2085, 2087), + Interval::new(2089, 2093), + Interval::new(2137, 2139), + Interval::new(2199, 2207), + Interval::new(2250, 2273), + Interval::new(2275, 2306), + Interval::new(2362, 2362), + Interval::new(2364, 2364), + Interval::new(2369, 2376), + Interval::new(2381, 2381), + Interval::new(2385, 2391), + Interval::new(2402, 2403), + Interval::new(2433, 2433), + Interval::new(2492, 2492), + Interval::new(2497, 2500), + Interval::new(2509, 2509), + Interval::new(2530, 2531), + Interval::new(2558, 2558), + Interval::new(2561, 2562), + Interval::new(2620, 2620), + Interval::new(2625, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2672, 2673), + Interval::new(2677, 2677), + Interval::new(2689, 2690), + Interval::new(2748, 2748), + Interval::new(2753, 2757), + Interval::new(2759, 2760), + Interval::new(2765, 2765), + Interval::new(2786, 2787), + Interval::new(2810, 2815), + Interval::new(2817, 2817), + Interval::new(2876, 2876), + Interval::new(2879, 2879), + Interval::new(2881, 2884), + Interval::new(2893, 2893), + Interval::new(2901, 2902), + Interval::new(2914, 2915), + Interval::new(2946, 2946), + Interval::new(3008, 3008), + Interval::new(3021, 3021), + Interval::new(3072, 3072), + Interval::new(3076, 3076), + Interval::new(3132, 3132), + Interval::new(3134, 3136), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3170, 3171), + Interval::new(3201, 3201), + Interval::new(3260, 3260), + Interval::new(3263, 3263), + Interval::new(3270, 3270), + Interval::new(3276, 3277), + Interval::new(3298, 3299), + Interval::new(3328, 3329), + Interval::new(3387, 3388), + Interval::new(3393, 3396), + Interval::new(3405, 3405), + Interval::new(3426, 3427), + Interval::new(3457, 3457), + Interval::new(3530, 3530), + Interval::new(3538, 3540), + Interval::new(3542, 3542), + Interval::new(3633, 3633), + Interval::new(3636, 3642), + Interval::new(3655, 3662), + Interval::new(3761, 3761), + Interval::new(3764, 3772), + Interval::new(3784, 3790), + Interval::new(3864, 3865), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3953, 3966), + Interval::new(3968, 3972), + Interval::new(3974, 3975), + Interval::new(3981, 3991), + Interval::new(3993, 4028), + Interval::new(4038, 4038), + Interval::new(4141, 4144), + Interval::new(4146, 4151), + Interval::new(4153, 4154), + Interval::new(4157, 4158), + Interval::new(4184, 4185), + Interval::new(4190, 4192), + Interval::new(4209, 4212), + Interval::new(4226, 4226), + Interval::new(4229, 4230), + Interval::new(4237, 4237), + Interval::new(4253, 4253), + Interval::new(4957, 4959), + Interval::new(5906, 5908), + Interval::new(5938, 5939), + Interval::new(5970, 5971), + Interval::new(6002, 6003), + Interval::new(6068, 6069), + Interval::new(6071, 6077), + Interval::new(6086, 6086), + Interval::new(6089, 6099), + Interval::new(6109, 6109), + Interval::new(6155, 6157), + Interval::new(6159, 6159), + Interval::new(6277, 6278), + Interval::new(6313, 6313), + Interval::new(6432, 6434), + Interval::new(6439, 6440), + Interval::new(6450, 6450), + Interval::new(6457, 6459), + Interval::new(6679, 6680), + Interval::new(6683, 6683), + Interval::new(6742, 6742), + Interval::new(6744, 6750), + Interval::new(6752, 6752), + Interval::new(6754, 6754), + Interval::new(6757, 6764), + Interval::new(6771, 6780), + Interval::new(6783, 6783), + Interval::new(6832, 6845), + Interval::new(6847, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6915), + Interval::new(6964, 6964), + Interval::new(6966, 6970), + Interval::new(6972, 6972), + Interval::new(6978, 6978), + Interval::new(7019, 7027), + Interval::new(7040, 7041), + Interval::new(7074, 7077), + Interval::new(7080, 7081), + Interval::new(7083, 7085), + Interval::new(7142, 7142), + Interval::new(7144, 7145), + Interval::new(7149, 7149), + Interval::new(7151, 7153), + Interval::new(7212, 7219), + Interval::new(7222, 7223), + Interval::new(7376, 7378), + Interval::new(7380, 7392), + Interval::new(7394, 7400), + Interval::new(7405, 7405), + Interval::new(7412, 7412), + Interval::new(7416, 7417), + Interval::new(7616, 7679), + Interval::new(8400, 8412), + Interval::new(8417, 8417), + Interval::new(8421, 8432), + Interval::new(11503, 11505), + Interval::new(11647, 11647), + Interval::new(11744, 11775), + Interval::new(12330, 12333), + Interval::new(12441, 12442), + Interval::new(42607, 42607), + Interval::new(42612, 42621), + Interval::new(42654, 42655), + Interval::new(42736, 42737), + Interval::new(43010, 43010), + Interval::new(43014, 43014), + Interval::new(43019, 43019), + Interval::new(43045, 43046), + Interval::new(43052, 43052), + Interval::new(43204, 43205), + Interval::new(43232, 43249), + Interval::new(43263, 43263), + Interval::new(43302, 43309), + Interval::new(43335, 43345), + Interval::new(43392, 43394), + Interval::new(43443, 43443), + Interval::new(43446, 43449), + Interval::new(43452, 43453), + Interval::new(43493, 43493), + Interval::new(43561, 43566), + Interval::new(43569, 43570), + Interval::new(43573, 43574), + Interval::new(43587, 43587), + Interval::new(43596, 43596), + Interval::new(43644, 43644), + Interval::new(43696, 43696), + Interval::new(43698, 43700), + Interval::new(43703, 43704), + Interval::new(43710, 43711), + Interval::new(43713, 43713), + Interval::new(43756, 43757), + Interval::new(43766, 43766), + Interval::new(44005, 44005), + Interval::new(44008, 44008), + Interval::new(44013, 44013), + Interval::new(64286, 64286), + Interval::new(65024, 65039), + Interval::new(65056, 65071), + Interval::new(66045, 66045), + Interval::new(66272, 66272), + Interval::new(66422, 66426), + Interval::new(68097, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68111), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68325, 68326), + Interval::new(68900, 68903), + Interval::new(68969, 68973), + Interval::new(69291, 69292), + Interval::new(69370, 69375), + Interval::new(69446, 69456), + Interval::new(69506, 69509), + Interval::new(69633, 69633), + Interval::new(69688, 69702), + Interval::new(69744, 69744), + Interval::new(69747, 69748), + Interval::new(69759, 69761), + Interval::new(69811, 69814), + Interval::new(69817, 69818), + Interval::new(69826, 69826), + Interval::new(69888, 69890), + Interval::new(69927, 69931), + Interval::new(69933, 69940), + Interval::new(70003, 70003), + Interval::new(70016, 70017), + Interval::new(70070, 70078), + Interval::new(70089, 70092), + Interval::new(70095, 70095), + Interval::new(70191, 70193), + Interval::new(70196, 70196), + Interval::new(70198, 70199), + Interval::new(70206, 70206), + Interval::new(70209, 70209), + Interval::new(70367, 70367), + Interval::new(70371, 70378), + Interval::new(70400, 70401), + Interval::new(70459, 70460), + Interval::new(70464, 70464), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70587, 70592), + Interval::new(70606, 70606), + Interval::new(70608, 70608), + Interval::new(70610, 70610), + Interval::new(70625, 70626), + Interval::new(70712, 70719), + Interval::new(70722, 70724), + Interval::new(70726, 70726), + Interval::new(70750, 70750), + Interval::new(70835, 70840), + Interval::new(70842, 70842), + Interval::new(70847, 70848), + Interval::new(70850, 70851), + Interval::new(71090, 71093), + Interval::new(71100, 71101), + Interval::new(71103, 71104), + Interval::new(71132, 71133), + Interval::new(71219, 71226), + Interval::new(71229, 71229), + Interval::new(71231, 71232), + Interval::new(71339, 71339), + Interval::new(71341, 71341), + Interval::new(71344, 71349), + Interval::new(71351, 71351), + Interval::new(71453, 71453), + Interval::new(71455, 71455), + Interval::new(71458, 71461), + Interval::new(71463, 71467), + Interval::new(71727, 71735), + Interval::new(71737, 71738), + Interval::new(71995, 71996), + Interval::new(71998, 71998), + Interval::new(72003, 72003), + Interval::new(72148, 72151), + Interval::new(72154, 72155), + Interval::new(72160, 72160), + Interval::new(72193, 72202), + Interval::new(72243, 72248), + Interval::new(72251, 72254), + Interval::new(72263, 72263), + Interval::new(72273, 72278), + Interval::new(72281, 72283), + Interval::new(72330, 72342), + Interval::new(72344, 72345), + Interval::new(72544, 72544), + Interval::new(72546, 72548), + Interval::new(72550, 72550), + Interval::new(72752, 72758), + Interval::new(72760, 72765), + Interval::new(72767, 72767), + Interval::new(72850, 72871), + Interval::new(72874, 72880), + Interval::new(72882, 72883), + Interval::new(72885, 72886), + Interval::new(73009, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73029), + Interval::new(73031, 73031), + Interval::new(73104, 73105), + Interval::new(73109, 73109), + Interval::new(73111, 73111), + Interval::new(73459, 73460), + Interval::new(73472, 73473), + Interval::new(73526, 73530), + Interval::new(73536, 73536), + Interval::new(73538, 73538), + Interval::new(73562, 73562), + Interval::new(78912, 78912), + Interval::new(78919, 78933), + Interval::new(90398, 90409), + Interval::new(90413, 90415), + Interval::new(92912, 92916), + Interval::new(92976, 92982), + Interval::new(94031, 94031), + Interval::new(94095, 94098), + Interval::new(94180, 94180), + Interval::new(113821, 113822), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119143, 119145), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(119362, 119364), + Interval::new(121344, 121398), + Interval::new(121403, 121452), + Interval::new(121461, 121461), + Interval::new(121476, 121476), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(123023, 123023), + Interval::new(123184, 123190), + Interval::new(123566, 123566), + Interval::new(123628, 123631), + Interval::new(124140, 124143), + Interval::new(124398, 124399), + Interval::new(124643, 124643), + Interval::new(124646, 124646), + Interval::new(124654, 124655), + Interval::new(124661, 124661), + Interval::new(125136, 125142), + Interval::new(125252, 125258), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'Nonspacing_Mark' Unicode property. +pub(crate) fn nonspacing_mark_ranges() -> &'static [Interval] { + &NONSPACING_MARK +} + +const OPEN_PUNCTUATION: [Interval; 79] = [ + Interval::new(40, 40), + Interval::new(91, 91), + Interval::new(123, 123), + Interval::new(3898, 3898), + Interval::new(3900, 3900), + Interval::new(5787, 5787), + Interval::new(8218, 8218), + Interval::new(8222, 8222), + Interval::new(8261, 8261), + Interval::new(8317, 8317), + Interval::new(8333, 8333), + Interval::new(8968, 8968), + Interval::new(8970, 8970), + Interval::new(9001, 9001), + Interval::new(10088, 10088), + Interval::new(10090, 10090), + Interval::new(10092, 10092), + Interval::new(10094, 10094), + Interval::new(10096, 10096), + Interval::new(10098, 10098), + Interval::new(10100, 10100), + Interval::new(10181, 10181), + Interval::new(10214, 10214), + Interval::new(10216, 10216), + Interval::new(10218, 10218), + Interval::new(10220, 10220), + Interval::new(10222, 10222), + Interval::new(10627, 10627), + Interval::new(10629, 10629), + Interval::new(10631, 10631), + Interval::new(10633, 10633), + Interval::new(10635, 10635), + Interval::new(10637, 10637), + Interval::new(10639, 10639), + Interval::new(10641, 10641), + Interval::new(10643, 10643), + Interval::new(10645, 10645), + Interval::new(10647, 10647), + Interval::new(10712, 10712), + Interval::new(10714, 10714), + Interval::new(10748, 10748), + Interval::new(11810, 11810), + Interval::new(11812, 11812), + Interval::new(11814, 11814), + Interval::new(11816, 11816), + Interval::new(11842, 11842), + Interval::new(11861, 11861), + Interval::new(11863, 11863), + Interval::new(11865, 11865), + Interval::new(11867, 11867), + Interval::new(12296, 12296), + Interval::new(12298, 12298), + Interval::new(12300, 12300), + Interval::new(12302, 12302), + Interval::new(12304, 12304), + Interval::new(12308, 12308), + Interval::new(12310, 12310), + Interval::new(12312, 12312), + Interval::new(12314, 12314), + Interval::new(12317, 12317), + Interval::new(64831, 64831), + Interval::new(65047, 65047), + Interval::new(65077, 65077), + Interval::new(65079, 65079), + Interval::new(65081, 65081), + Interval::new(65083, 65083), + Interval::new(65085, 65085), + Interval::new(65087, 65087), + Interval::new(65089, 65089), + Interval::new(65091, 65091), + Interval::new(65095, 65095), + Interval::new(65113, 65113), + Interval::new(65115, 65115), + Interval::new(65117, 65117), + Interval::new(65288, 65288), + Interval::new(65339, 65339), + Interval::new(65371, 65371), + Interval::new(65375, 65375), + Interval::new(65378, 65378), +]; + +/// Return the code point ranges of the 'Open_Punctuation' Unicode property. +pub(crate) fn open_punctuation_ranges() -> &'static [Interval] { + &OPEN_PUNCTUATION +} + +const OTHER_LETTER: [Interval; 537] = [ + Interval::new(170, 170), + Interval::new(186, 186), + Interval::new(443, 443), + Interval::new(448, 451), + Interval::new(660, 661), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1568, 1599), + Interval::new(1601, 1610), + Interval::new(1646, 1647), + Interval::new(1649, 1747), + Interval::new(1749, 1749), + Interval::new(1774, 1775), + Interval::new(1786, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1808), + Interval::new(1810, 1839), + Interval::new(1869, 1957), + Interval::new(1969, 1969), + Interval::new(1994, 2026), + Interval::new(2048, 2069), + Interval::new(2112, 2136), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2208, 2248), + Interval::new(2308, 2361), + Interval::new(2365, 2365), + Interval::new(2384, 2384), + Interval::new(2392, 2401), + Interval::new(2418, 2432), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2493, 2493), + Interval::new(2510, 2510), + Interval::new(2524, 2525), + Interval::new(2527, 2529), + Interval::new(2544, 2545), + Interval::new(2556, 2556), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2674, 2676), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2749, 2749), + Interval::new(2768, 2768), + Interval::new(2784, 2785), + Interval::new(2809, 2809), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2877, 2877), + Interval::new(2908, 2909), + Interval::new(2911, 2913), + Interval::new(2929, 2929), + Interval::new(2947, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3024, 3024), + Interval::new(3077, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3133, 3133), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3169), + Interval::new(3200, 3200), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3261, 3261), + Interval::new(3292, 3294), + Interval::new(3296, 3297), + Interval::new(3313, 3314), + Interval::new(3332, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3386), + Interval::new(3389, 3389), + Interval::new(3406, 3406), + Interval::new(3412, 3414), + Interval::new(3423, 3425), + Interval::new(3450, 3455), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3585, 3632), + Interval::new(3634, 3635), + Interval::new(3648, 3653), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3760), + Interval::new(3762, 3763), + Interval::new(3773, 3773), + Interval::new(3776, 3780), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3904, 3911), + Interval::new(3913, 3948), + Interval::new(3976, 3980), + Interval::new(4096, 4138), + Interval::new(4159, 4159), + Interval::new(4176, 4181), + Interval::new(4186, 4189), + Interval::new(4193, 4193), + Interval::new(4197, 4198), + Interval::new(4206, 4208), + Interval::new(4213, 4225), + Interval::new(4238, 4238), + Interval::new(4352, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4992, 5007), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5873, 5880), + Interval::new(5888, 5905), + Interval::new(5919, 5937), + Interval::new(5952, 5969), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6016, 6067), + Interval::new(6108, 6108), + Interval::new(6176, 6210), + Interval::new(6212, 6264), + Interval::new(6272, 6276), + Interval::new(6279, 6312), + Interval::new(6314, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6480, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6656, 6678), + Interval::new(6688, 6740), + Interval::new(6917, 6963), + Interval::new(6981, 6988), + Interval::new(7043, 7072), + Interval::new(7086, 7087), + Interval::new(7098, 7141), + Interval::new(7168, 7203), + Interval::new(7245, 7247), + Interval::new(7258, 7287), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7414), + Interval::new(7418, 7418), + Interval::new(8501, 8504), + Interval::new(11568, 11623), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(12294, 12294), + Interval::new(12348, 12348), + Interval::new(12353, 12438), + Interval::new(12447, 12447), + Interval::new(12449, 12538), + Interval::new(12543, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 40980), + Interval::new(40982, 42124), + Interval::new(42192, 42231), + Interval::new(42240, 42507), + Interval::new(42512, 42527), + Interval::new(42538, 42539), + Interval::new(42606, 42606), + Interval::new(42656, 42725), + Interval::new(42895, 42895), + Interval::new(42999, 42999), + Interval::new(43003, 43009), + Interval::new(43011, 43013), + Interval::new(43015, 43018), + Interval::new(43020, 43042), + Interval::new(43072, 43123), + Interval::new(43138, 43187), + Interval::new(43250, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43262), + Interval::new(43274, 43301), + Interval::new(43312, 43334), + Interval::new(43360, 43388), + Interval::new(43396, 43442), + Interval::new(43488, 43492), + Interval::new(43495, 43503), + Interval::new(43514, 43518), + Interval::new(43520, 43560), + Interval::new(43584, 43586), + Interval::new(43588, 43595), + Interval::new(43616, 43631), + Interval::new(43633, 43638), + Interval::new(43642, 43642), + Interval::new(43646, 43695), + Interval::new(43697, 43697), + Interval::new(43701, 43702), + Interval::new(43705, 43709), + Interval::new(43712, 43712), + Interval::new(43714, 43714), + Interval::new(43739, 43740), + Interval::new(43744, 43754), + Interval::new(43762, 43762), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43968, 44002), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64285, 64285), + Interval::new(64287, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65019), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65382, 65391), + Interval::new(65393, 65437), + Interval::new(65440, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66304, 66335), + Interval::new(66349, 66368), + Interval::new(66370, 66377), + Interval::new(66384, 66421), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66640, 66717), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68096), + Interval::new(68112, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68324), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68864, 68899), + Interval::new(68938, 68941), + Interval::new(68943, 68943), + Interval::new(69248, 69289), + Interval::new(69296, 69297), + Interval::new(69314, 69316), + Interval::new(69318, 69319), + Interval::new(69376, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69445), + Interval::new(69488, 69505), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69635, 69687), + Interval::new(69745, 69746), + Interval::new(69749, 69749), + Interval::new(69763, 69807), + Interval::new(69840, 69864), + Interval::new(69891, 69926), + Interval::new(69956, 69956), + Interval::new(69959, 69959), + Interval::new(69968, 70002), + Interval::new(70006, 70006), + Interval::new(70019, 70066), + Interval::new(70081, 70084), + Interval::new(70106, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70187), + Interval::new(70207, 70208), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70366), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70461, 70461), + Interval::new(70480, 70480), + Interval::new(70493, 70497), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70583), + Interval::new(70609, 70609), + Interval::new(70611, 70611), + Interval::new(70656, 70708), + Interval::new(70727, 70730), + Interval::new(70751, 70753), + Interval::new(70784, 70831), + Interval::new(70852, 70853), + Interval::new(70855, 70855), + Interval::new(71040, 71086), + Interval::new(71128, 71131), + Interval::new(71168, 71215), + Interval::new(71236, 71236), + Interval::new(71296, 71338), + Interval::new(71352, 71352), + Interval::new(71424, 71450), + Interval::new(71488, 71494), + Interval::new(71680, 71723), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71983), + Interval::new(71999, 71999), + Interval::new(72001, 72001), + Interval::new(72096, 72103), + Interval::new(72106, 72144), + Interval::new(72161, 72161), + Interval::new(72163, 72163), + Interval::new(72192, 72192), + Interval::new(72203, 72242), + Interval::new(72250, 72250), + Interval::new(72272, 72272), + Interval::new(72284, 72329), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72640, 72672), + Interval::new(72704, 72712), + Interval::new(72714, 72750), + Interval::new(72768, 72768), + Interval::new(72818, 72847), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73008), + Interval::new(73030, 73030), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73097), + Interval::new(73112, 73112), + Interval::new(73136, 73176), + Interval::new(73178, 73179), + Interval::new(73440, 73458), + Interval::new(73474, 73474), + Interval::new(73476, 73488), + Interval::new(73490, 73523), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78913, 78918), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90397), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92784, 92862), + Interval::new(92880, 92909), + Interval::new(92928, 92975), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93507, 93546), + Interval::new(93952, 94026), + Interval::new(94032, 94032), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(122634, 122634), + Interval::new(123136, 123180), + Interval::new(123214, 123214), + Interval::new(123536, 123565), + Interval::new(123584, 123627), + Interval::new(124112, 124138), + Interval::new(124368, 124397), + Interval::new(124400, 124400), + Interval::new(124608, 124638), + Interval::new(124640, 124642), + Interval::new(124644, 124645), + Interval::new(124647, 124653), + Interval::new(124656, 124660), + Interval::new(124670, 124670), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'Other_Letter' Unicode property. +pub(crate) fn other_letter_ranges() -> &'static [Interval] { + &OTHER_LETTER +} + +const OTHER_NUMBER: [Interval; 72] = [ + Interval::new(178, 179), + Interval::new(185, 185), + Interval::new(188, 190), + Interval::new(2548, 2553), + Interval::new(2930, 2935), + Interval::new(3056, 3058), + Interval::new(3192, 3198), + Interval::new(3416, 3422), + Interval::new(3440, 3448), + Interval::new(3882, 3891), + Interval::new(4969, 4988), + Interval::new(6128, 6137), + Interval::new(6618, 6618), + Interval::new(8304, 8304), + Interval::new(8308, 8313), + Interval::new(8320, 8329), + Interval::new(8528, 8543), + Interval::new(8585, 8585), + Interval::new(9312, 9371), + Interval::new(9450, 9471), + Interval::new(10102, 10131), + Interval::new(11517, 11517), + Interval::new(12690, 12693), + Interval::new(12832, 12841), + Interval::new(12872, 12879), + Interval::new(12881, 12895), + Interval::new(12928, 12937), + Interval::new(12977, 12991), + Interval::new(43056, 43061), + Interval::new(65799, 65843), + Interval::new(65909, 65912), + Interval::new(65930, 65931), + Interval::new(66273, 66299), + Interval::new(66336, 66339), + Interval::new(67672, 67679), + Interval::new(67705, 67711), + Interval::new(67751, 67759), + Interval::new(67835, 67839), + Interval::new(67862, 67867), + Interval::new(68028, 68029), + Interval::new(68032, 68047), + Interval::new(68050, 68095), + Interval::new(68160, 68168), + Interval::new(68221, 68222), + Interval::new(68253, 68255), + Interval::new(68331, 68335), + Interval::new(68440, 68447), + Interval::new(68472, 68479), + Interval::new(68521, 68527), + Interval::new(68858, 68863), + Interval::new(69216, 69246), + Interval::new(69405, 69414), + Interval::new(69457, 69460), + Interval::new(69573, 69579), + Interval::new(69714, 69733), + Interval::new(70113, 70132), + Interval::new(71482, 71483), + Interval::new(71914, 71922), + Interval::new(72794, 72812), + Interval::new(73664, 73684), + Interval::new(93019, 93025), + Interval::new(93824, 93846), + Interval::new(119488, 119507), + Interval::new(119520, 119539), + Interval::new(119648, 119672), + Interval::new(125127, 125135), + Interval::new(126065, 126123), + Interval::new(126125, 126127), + Interval::new(126129, 126132), + Interval::new(126209, 126253), + Interval::new(126255, 126269), + Interval::new(127232, 127244), +]; + +/// Return the code point ranges of the 'Other_Number' Unicode property. +pub(crate) fn other_number_ranges() -> &'static [Interval] { + &OTHER_NUMBER +} + +const OTHER_PUNCTUATION: [Interval; 194] = [ + Interval::new(33, 35), + Interval::new(37, 39), + Interval::new(42, 42), + Interval::new(44, 44), + Interval::new(46, 47), + Interval::new(58, 59), + Interval::new(63, 64), + Interval::new(92, 92), + Interval::new(161, 161), + Interval::new(167, 167), + Interval::new(182, 183), + Interval::new(191, 191), + Interval::new(894, 894), + Interval::new(903, 903), + Interval::new(1370, 1375), + Interval::new(1417, 1417), + Interval::new(1472, 1472), + Interval::new(1475, 1475), + Interval::new(1478, 1478), + Interval::new(1523, 1524), + Interval::new(1545, 1546), + Interval::new(1548, 1549), + Interval::new(1563, 1563), + Interval::new(1565, 1567), + Interval::new(1642, 1645), + Interval::new(1748, 1748), + Interval::new(1792, 1805), + Interval::new(2039, 2041), + Interval::new(2096, 2110), + Interval::new(2142, 2142), + Interval::new(2404, 2405), + Interval::new(2416, 2416), + Interval::new(2557, 2557), + Interval::new(2678, 2678), + Interval::new(2800, 2800), + Interval::new(3191, 3191), + Interval::new(3204, 3204), + Interval::new(3572, 3572), + Interval::new(3663, 3663), + Interval::new(3674, 3675), + Interval::new(3844, 3858), + Interval::new(3860, 3860), + Interval::new(3973, 3973), + Interval::new(4048, 4052), + Interval::new(4057, 4058), + Interval::new(4170, 4175), + Interval::new(4347, 4347), + Interval::new(4960, 4968), + Interval::new(5742, 5742), + Interval::new(5867, 5869), + Interval::new(5941, 5942), + Interval::new(6100, 6102), + Interval::new(6104, 6106), + Interval::new(6144, 6149), + Interval::new(6151, 6154), + Interval::new(6468, 6469), + Interval::new(6686, 6687), + Interval::new(6816, 6822), + Interval::new(6824, 6829), + Interval::new(6990, 6991), + Interval::new(7002, 7008), + Interval::new(7037, 7039), + Interval::new(7164, 7167), + Interval::new(7227, 7231), + Interval::new(7294, 7295), + Interval::new(7360, 7367), + Interval::new(7379, 7379), + Interval::new(8214, 8215), + Interval::new(8224, 8231), + Interval::new(8240, 8248), + Interval::new(8251, 8254), + Interval::new(8257, 8259), + Interval::new(8263, 8273), + Interval::new(8275, 8275), + Interval::new(8277, 8286), + Interval::new(11513, 11516), + Interval::new(11518, 11519), + Interval::new(11632, 11632), + Interval::new(11776, 11777), + Interval::new(11782, 11784), + Interval::new(11787, 11787), + Interval::new(11790, 11798), + Interval::new(11800, 11801), + Interval::new(11803, 11803), + Interval::new(11806, 11807), + Interval::new(11818, 11822), + Interval::new(11824, 11833), + Interval::new(11836, 11839), + Interval::new(11841, 11841), + Interval::new(11843, 11855), + Interval::new(11858, 11860), + Interval::new(12289, 12291), + Interval::new(12349, 12349), + Interval::new(12539, 12539), + Interval::new(42238, 42239), + Interval::new(42509, 42511), + Interval::new(42611, 42611), + Interval::new(42622, 42622), + Interval::new(42738, 42743), + Interval::new(43124, 43127), + Interval::new(43214, 43215), + Interval::new(43256, 43258), + Interval::new(43260, 43260), + Interval::new(43310, 43311), + Interval::new(43359, 43359), + Interval::new(43457, 43469), + Interval::new(43486, 43487), + Interval::new(43612, 43615), + Interval::new(43742, 43743), + Interval::new(43760, 43761), + Interval::new(44011, 44011), + Interval::new(65040, 65046), + Interval::new(65049, 65049), + Interval::new(65072, 65072), + Interval::new(65093, 65094), + Interval::new(65097, 65100), + Interval::new(65104, 65106), + Interval::new(65108, 65111), + Interval::new(65119, 65121), + Interval::new(65128, 65128), + Interval::new(65130, 65131), + Interval::new(65281, 65283), + Interval::new(65285, 65287), + Interval::new(65290, 65290), + Interval::new(65292, 65292), + Interval::new(65294, 65295), + Interval::new(65306, 65307), + Interval::new(65311, 65312), + Interval::new(65340, 65340), + Interval::new(65377, 65377), + Interval::new(65380, 65381), + Interval::new(65792, 65794), + Interval::new(66463, 66463), + Interval::new(66512, 66512), + Interval::new(66927, 66927), + Interval::new(67671, 67671), + Interval::new(67871, 67871), + Interval::new(67903, 67903), + Interval::new(68176, 68184), + Interval::new(68223, 68223), + Interval::new(68336, 68342), + Interval::new(68409, 68415), + Interval::new(68505, 68508), + Interval::new(69328, 69328), + Interval::new(69461, 69465), + Interval::new(69510, 69513), + Interval::new(69703, 69709), + Interval::new(69819, 69820), + Interval::new(69822, 69825), + Interval::new(69952, 69955), + Interval::new(70004, 70005), + Interval::new(70085, 70088), + Interval::new(70093, 70093), + Interval::new(70107, 70107), + Interval::new(70109, 70111), + Interval::new(70200, 70205), + Interval::new(70313, 70313), + Interval::new(70612, 70613), + Interval::new(70615, 70616), + Interval::new(70731, 70735), + Interval::new(70746, 70747), + Interval::new(70749, 70749), + Interval::new(70854, 70854), + Interval::new(71105, 71127), + Interval::new(71233, 71235), + Interval::new(71264, 71276), + Interval::new(71353, 71353), + Interval::new(71484, 71486), + Interval::new(71739, 71739), + Interval::new(72004, 72006), + Interval::new(72162, 72162), + Interval::new(72255, 72262), + Interval::new(72346, 72348), + Interval::new(72350, 72354), + Interval::new(72448, 72457), + Interval::new(72673, 72673), + Interval::new(72769, 72773), + Interval::new(72816, 72817), + Interval::new(73463, 73464), + Interval::new(73539, 73551), + Interval::new(73727, 73727), + Interval::new(74864, 74868), + Interval::new(77809, 77810), + Interval::new(92782, 92783), + Interval::new(92917, 92917), + Interval::new(92983, 92987), + Interval::new(92996, 92996), + Interval::new(93549, 93551), + Interval::new(93847, 93850), + Interval::new(94178, 94178), + Interval::new(113823, 113823), + Interval::new(121479, 121483), + Interval::new(124415, 124415), + Interval::new(125278, 125279), +]; + +/// Return the code point ranges of the 'Other_Punctuation' Unicode property. +pub(crate) fn other_punctuation_ranges() -> &'static [Interval] { + &OTHER_PUNCTUATION +} + +const OTHER_SYMBOL: [Interval; 193] = [ + Interval::new(166, 166), + Interval::new(169, 169), + Interval::new(174, 174), + Interval::new(176, 176), + Interval::new(1154, 1154), + Interval::new(1421, 1422), + Interval::new(1550, 1551), + Interval::new(1758, 1758), + Interval::new(1769, 1769), + Interval::new(1789, 1790), + Interval::new(2038, 2038), + Interval::new(2554, 2554), + Interval::new(2928, 2928), + Interval::new(3059, 3064), + Interval::new(3066, 3066), + Interval::new(3199, 3199), + Interval::new(3407, 3407), + Interval::new(3449, 3449), + Interval::new(3841, 3843), + Interval::new(3859, 3859), + Interval::new(3861, 3863), + Interval::new(3866, 3871), + Interval::new(3892, 3892), + Interval::new(3894, 3894), + Interval::new(3896, 3896), + Interval::new(4030, 4037), + Interval::new(4039, 4044), + Interval::new(4046, 4047), + Interval::new(4053, 4056), + Interval::new(4254, 4255), + Interval::new(5008, 5017), + Interval::new(5741, 5741), + Interval::new(6464, 6464), + Interval::new(6622, 6655), + Interval::new(7009, 7018), + Interval::new(7028, 7036), + Interval::new(8448, 8449), + Interval::new(8451, 8454), + Interval::new(8456, 8457), + Interval::new(8468, 8468), + Interval::new(8470, 8471), + Interval::new(8478, 8483), + Interval::new(8485, 8485), + Interval::new(8487, 8487), + Interval::new(8489, 8489), + Interval::new(8494, 8494), + Interval::new(8506, 8507), + Interval::new(8522, 8522), + Interval::new(8524, 8525), + Interval::new(8527, 8527), + Interval::new(8586, 8587), + Interval::new(8597, 8601), + Interval::new(8604, 8607), + Interval::new(8609, 8610), + Interval::new(8612, 8613), + Interval::new(8615, 8621), + Interval::new(8623, 8653), + Interval::new(8656, 8657), + Interval::new(8659, 8659), + Interval::new(8661, 8691), + Interval::new(8960, 8967), + Interval::new(8972, 8991), + Interval::new(8994, 9000), + Interval::new(9003, 9083), + Interval::new(9085, 9114), + Interval::new(9140, 9179), + Interval::new(9186, 9257), + Interval::new(9280, 9290), + Interval::new(9372, 9449), + Interval::new(9472, 9654), + Interval::new(9656, 9664), + Interval::new(9666, 9719), + Interval::new(9728, 9838), + Interval::new(9840, 10087), + Interval::new(10132, 10175), + Interval::new(10240, 10495), + Interval::new(11008, 11055), + Interval::new(11077, 11078), + Interval::new(11085, 11123), + Interval::new(11126, 11263), + Interval::new(11493, 11498), + Interval::new(11856, 11857), + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), + Interval::new(12272, 12287), + Interval::new(12292, 12292), + Interval::new(12306, 12307), + Interval::new(12320, 12320), + Interval::new(12342, 12343), + Interval::new(12350, 12351), + Interval::new(12688, 12689), + Interval::new(12694, 12703), + Interval::new(12736, 12773), + Interval::new(12783, 12783), + Interval::new(12800, 12830), + Interval::new(12842, 12871), + Interval::new(12880, 12880), + Interval::new(12896, 12927), + Interval::new(12938, 12976), + Interval::new(12992, 13311), + Interval::new(19904, 19967), + Interval::new(42128, 42182), + Interval::new(43048, 43051), + Interval::new(43062, 43063), + Interval::new(43065, 43065), + Interval::new(43639, 43641), + Interval::new(64451, 64466), + Interval::new(64832, 64847), + Interval::new(64912, 64913), + Interval::new(64968, 64975), + Interval::new(65021, 65023), + Interval::new(65508, 65508), + Interval::new(65512, 65512), + Interval::new(65517, 65518), + Interval::new(65532, 65533), + Interval::new(65847, 65855), + Interval::new(65913, 65929), + Interval::new(65932, 65934), + Interval::new(65936, 65948), + Interval::new(65952, 65952), + Interval::new(66000, 66044), + Interval::new(67703, 67704), + Interval::new(68296, 68296), + Interval::new(69329, 69336), + Interval::new(71487, 71487), + Interval::new(73685, 73692), + Interval::new(73697, 73713), + Interval::new(92988, 92991), + Interval::new(92997, 92997), + Interval::new(113820, 113820), + Interval::new(117760, 117999), + Interval::new(118010, 118012), + Interval::new(118016, 118451), + Interval::new(118458, 118480), + Interval::new(118496, 118511), + Interval::new(118608, 118723), + Interval::new(118784, 119029), + Interval::new(119040, 119078), + Interval::new(119081, 119140), + Interval::new(119146, 119148), + Interval::new(119171, 119172), + Interval::new(119180, 119209), + Interval::new(119214, 119274), + Interval::new(119296, 119361), + Interval::new(119365, 119365), + Interval::new(119552, 119638), + Interval::new(120832, 121343), + Interval::new(121399, 121402), + Interval::new(121453, 121460), + Interval::new(121462, 121475), + Interval::new(121477, 121478), + Interval::new(123215, 123215), + Interval::new(126124, 126124), + Interval::new(126254, 126254), + Interval::new(126976, 127019), + Interval::new(127024, 127123), + Interval::new(127136, 127150), + Interval::new(127153, 127167), + Interval::new(127169, 127183), + Interval::new(127185, 127221), + Interval::new(127245, 127405), + Interval::new(127462, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127568, 127569), + Interval::new(127584, 127589), + Interval::new(127744, 127994), + Interval::new(128000, 128728), + Interval::new(128732, 128748), + Interval::new(128752, 128764), + Interval::new(128768, 128985), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129024, 129035), + Interval::new(129040, 129095), + Interval::new(129104, 129113), + Interval::new(129120, 129159), + Interval::new(129168, 129197), + Interval::new(129200, 129211), + Interval::new(129216, 129217), + Interval::new(129280, 129623), + Interval::new(129632, 129645), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), + Interval::new(129792, 129938), + Interval::new(129940, 130031), + Interval::new(130042, 130042), +]; + +/// Return the code point ranges of the 'Other_Symbol' Unicode property. +pub(crate) fn other_symbol_ranges() -> &'static [Interval] { + &OTHER_SYMBOL +} + +const PARAGRAPH_SEPARATOR: [Interval; 1] = [Interval::new(8233, 8233)]; + +/// Return the code point ranges of the 'Paragraph_Separator' Unicode property. +pub(crate) fn paragraph_separator_ranges() -> &'static [Interval] { + &PARAGRAPH_SEPARATOR +} + +const PRIVATE_USE: [Interval; 3] = [ + Interval::new(57344, 63743), + Interval::new(983040, 1048573), + Interval::new(1048576, 1114109), +]; + +/// Return the code point ranges of the 'Private_Use' Unicode property. +pub(crate) fn private_use_ranges() -> &'static [Interval] { + &PRIVATE_USE +} + +const SPACE_SEPARATOR: [Interval; 7] = [ + Interval::new(32, 32), + Interval::new(160, 160), + Interval::new(5760, 5760), + Interval::new(8192, 8202), + Interval::new(8239, 8239), + Interval::new(8287, 8287), + Interval::new(12288, 12288), +]; + +/// Return the code point ranges of the 'Space_Separator' Unicode property. +pub(crate) fn space_separator_ranges() -> &'static [Interval] { + &SPACE_SEPARATOR +} + +const SPACING_MARK: [Interval; 193] = [ + Interval::new(2307, 2307), + Interval::new(2363, 2363), + Interval::new(2366, 2368), + Interval::new(2377, 2380), + Interval::new(2382, 2383), + Interval::new(2434, 2435), + Interval::new(2494, 2496), + Interval::new(2503, 2504), + Interval::new(2507, 2508), + Interval::new(2519, 2519), + Interval::new(2563, 2563), + Interval::new(2622, 2624), + Interval::new(2691, 2691), + Interval::new(2750, 2752), + Interval::new(2761, 2761), + Interval::new(2763, 2764), + Interval::new(2818, 2819), + Interval::new(2878, 2878), + Interval::new(2880, 2880), + Interval::new(2887, 2888), + Interval::new(2891, 2892), + Interval::new(2903, 2903), + Interval::new(3006, 3007), + Interval::new(3009, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3020), + Interval::new(3031, 3031), + Interval::new(3073, 3075), + Interval::new(3137, 3140), + Interval::new(3202, 3203), + Interval::new(3262, 3262), + Interval::new(3264, 3268), + Interval::new(3271, 3272), + Interval::new(3274, 3275), + Interval::new(3285, 3286), + Interval::new(3315, 3315), + Interval::new(3330, 3331), + Interval::new(3390, 3392), + Interval::new(3398, 3400), + Interval::new(3402, 3404), + Interval::new(3415, 3415), + Interval::new(3458, 3459), + Interval::new(3535, 3537), + Interval::new(3544, 3551), + Interval::new(3570, 3571), + Interval::new(3902, 3903), + Interval::new(3967, 3967), + Interval::new(4139, 4140), + Interval::new(4145, 4145), + Interval::new(4152, 4152), + Interval::new(4155, 4156), + Interval::new(4182, 4183), + Interval::new(4194, 4196), + Interval::new(4199, 4205), + Interval::new(4227, 4228), + Interval::new(4231, 4236), + Interval::new(4239, 4239), + Interval::new(4250, 4252), + Interval::new(5909, 5909), + Interval::new(5940, 5940), + Interval::new(6070, 6070), + Interval::new(6078, 6085), + Interval::new(6087, 6088), + Interval::new(6435, 6438), + Interval::new(6441, 6443), + Interval::new(6448, 6449), + Interval::new(6451, 6456), + Interval::new(6681, 6682), + Interval::new(6741, 6741), + Interval::new(6743, 6743), + Interval::new(6753, 6753), + Interval::new(6755, 6756), + Interval::new(6765, 6770), + Interval::new(6916, 6916), + Interval::new(6965, 6965), + Interval::new(6971, 6971), + Interval::new(6973, 6977), + Interval::new(6979, 6980), + Interval::new(7042, 7042), + Interval::new(7073, 7073), + Interval::new(7078, 7079), + Interval::new(7082, 7082), + Interval::new(7143, 7143), + Interval::new(7146, 7148), + Interval::new(7150, 7150), + Interval::new(7154, 7155), + Interval::new(7204, 7211), + Interval::new(7220, 7221), + Interval::new(7393, 7393), + Interval::new(7415, 7415), + Interval::new(12334, 12335), + Interval::new(43043, 43044), + Interval::new(43047, 43047), + Interval::new(43136, 43137), + Interval::new(43188, 43203), + Interval::new(43346, 43347), + Interval::new(43395, 43395), + Interval::new(43444, 43445), + Interval::new(43450, 43451), + Interval::new(43454, 43456), + Interval::new(43567, 43568), + Interval::new(43571, 43572), + Interval::new(43597, 43597), + Interval::new(43643, 43643), + Interval::new(43645, 43645), + Interval::new(43755, 43755), + Interval::new(43758, 43759), + Interval::new(43765, 43765), + Interval::new(44003, 44004), + Interval::new(44006, 44007), + Interval::new(44009, 44010), + Interval::new(44012, 44012), + Interval::new(69632, 69632), + Interval::new(69634, 69634), + Interval::new(69762, 69762), + Interval::new(69808, 69810), + Interval::new(69815, 69816), + Interval::new(69932, 69932), + Interval::new(69957, 69958), + Interval::new(70018, 70018), + Interval::new(70067, 70069), + Interval::new(70079, 70080), + Interval::new(70094, 70094), + Interval::new(70188, 70190), + Interval::new(70194, 70195), + Interval::new(70197, 70197), + Interval::new(70368, 70370), + Interval::new(70402, 70403), + Interval::new(70462, 70463), + Interval::new(70465, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70487, 70487), + Interval::new(70498, 70499), + Interval::new(70584, 70586), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70605), + Interval::new(70607, 70607), + Interval::new(70709, 70711), + Interval::new(70720, 70721), + Interval::new(70725, 70725), + Interval::new(70832, 70834), + Interval::new(70841, 70841), + Interval::new(70843, 70846), + Interval::new(70849, 70849), + Interval::new(71087, 71089), + Interval::new(71096, 71099), + Interval::new(71102, 71102), + Interval::new(71216, 71218), + Interval::new(71227, 71228), + Interval::new(71230, 71230), + Interval::new(71340, 71340), + Interval::new(71342, 71343), + Interval::new(71350, 71350), + Interval::new(71454, 71454), + Interval::new(71456, 71457), + Interval::new(71462, 71462), + Interval::new(71724, 71726), + Interval::new(71736, 71736), + Interval::new(71984, 71989), + Interval::new(71991, 71992), + Interval::new(71997, 71997), + Interval::new(72000, 72000), + Interval::new(72002, 72002), + Interval::new(72145, 72147), + Interval::new(72156, 72159), + Interval::new(72164, 72164), + Interval::new(72249, 72249), + Interval::new(72279, 72280), + Interval::new(72343, 72343), + Interval::new(72545, 72545), + Interval::new(72549, 72549), + Interval::new(72551, 72551), + Interval::new(72751, 72751), + Interval::new(72766, 72766), + Interval::new(72873, 72873), + Interval::new(72881, 72881), + Interval::new(72884, 72884), + Interval::new(73098, 73102), + Interval::new(73107, 73108), + Interval::new(73110, 73110), + Interval::new(73461, 73462), + Interval::new(73475, 73475), + Interval::new(73524, 73525), + Interval::new(73534, 73535), + Interval::new(73537, 73537), + Interval::new(90410, 90412), + Interval::new(94033, 94087), + Interval::new(94192, 94193), + Interval::new(119141, 119142), + Interval::new(119149, 119154), +]; + +/// Return the code point ranges of the 'Spacing_Mark' Unicode property. +pub(crate) fn spacing_mark_ranges() -> &'static [Interval] { + &SPACING_MARK +} + +const SURROGATE: [Interval; 1] = [Interval::new(55296, 57343)]; + +/// Return the code point ranges of the 'Surrogate' Unicode property. +pub(crate) fn surrogate_ranges() -> &'static [Interval] { + &SURROGATE +} + +const TITLECASE_LETTER: [Interval; 10] = [ + Interval::new(453, 453), + Interval::new(456, 456), + Interval::new(459, 459), + Interval::new(498, 498), + Interval::new(8072, 8079), + Interval::new(8088, 8095), + Interval::new(8104, 8111), + Interval::new(8124, 8124), + Interval::new(8140, 8140), + Interval::new(8188, 8188), +]; + +/// Return the code point ranges of the 'Titlecase_Letter' Unicode property. +pub(crate) fn titlecase_letter_ranges() -> &'static [Interval] { + &TITLECASE_LETTER +} + +const UNASSIGNED: [Interval; 735] = [ + Interval::new(888, 889), + Interval::new(896, 899), + Interval::new(907, 907), + Interval::new(909, 909), + Interval::new(930, 930), + Interval::new(1328, 1328), + Interval::new(1367, 1368), + Interval::new(1419, 1420), + Interval::new(1424, 1424), + Interval::new(1480, 1487), + Interval::new(1515, 1518), + Interval::new(1525, 1535), + Interval::new(1806, 1806), + Interval::new(1867, 1868), + Interval::new(1970, 1983), + Interval::new(2043, 2044), + Interval::new(2094, 2095), + Interval::new(2111, 2111), + Interval::new(2140, 2141), + Interval::new(2143, 2143), + Interval::new(2155, 2159), + Interval::new(2194, 2198), + Interval::new(2436, 2436), + Interval::new(2445, 2446), + Interval::new(2449, 2450), + Interval::new(2473, 2473), + Interval::new(2481, 2481), + Interval::new(2483, 2485), + Interval::new(2490, 2491), + Interval::new(2501, 2502), + Interval::new(2505, 2506), + Interval::new(2511, 2518), + Interval::new(2520, 2523), + Interval::new(2526, 2526), + Interval::new(2532, 2533), + Interval::new(2559, 2560), + Interval::new(2564, 2564), + Interval::new(2571, 2574), + Interval::new(2577, 2578), + Interval::new(2601, 2601), + Interval::new(2609, 2609), + Interval::new(2612, 2612), + Interval::new(2615, 2615), + Interval::new(2618, 2619), + Interval::new(2621, 2621), + Interval::new(2627, 2630), + Interval::new(2633, 2634), + Interval::new(2638, 2640), + Interval::new(2642, 2648), + Interval::new(2653, 2653), + Interval::new(2655, 2661), + Interval::new(2679, 2688), + Interval::new(2692, 2692), + Interval::new(2702, 2702), + Interval::new(2706, 2706), + Interval::new(2729, 2729), + Interval::new(2737, 2737), + Interval::new(2740, 2740), + Interval::new(2746, 2747), + Interval::new(2758, 2758), + Interval::new(2762, 2762), + Interval::new(2766, 2767), + Interval::new(2769, 2783), + Interval::new(2788, 2789), + Interval::new(2802, 2808), + Interval::new(2816, 2816), + Interval::new(2820, 2820), + Interval::new(2829, 2830), + Interval::new(2833, 2834), + Interval::new(2857, 2857), + Interval::new(2865, 2865), + Interval::new(2868, 2868), + Interval::new(2874, 2875), + Interval::new(2885, 2886), + Interval::new(2889, 2890), + Interval::new(2894, 2900), + Interval::new(2904, 2907), + Interval::new(2910, 2910), + Interval::new(2916, 2917), + Interval::new(2936, 2945), + Interval::new(2948, 2948), + Interval::new(2955, 2957), + Interval::new(2961, 2961), + Interval::new(2966, 2968), + Interval::new(2971, 2971), + Interval::new(2973, 2973), + Interval::new(2976, 2978), + Interval::new(2981, 2983), + Interval::new(2987, 2989), + Interval::new(3002, 3005), + Interval::new(3011, 3013), + Interval::new(3017, 3017), + Interval::new(3022, 3023), + Interval::new(3025, 3030), + Interval::new(3032, 3045), + Interval::new(3067, 3071), + Interval::new(3085, 3085), + Interval::new(3089, 3089), + Interval::new(3113, 3113), + Interval::new(3130, 3131), + Interval::new(3141, 3141), + Interval::new(3145, 3145), + Interval::new(3150, 3156), + Interval::new(3159, 3159), + Interval::new(3163, 3163), + Interval::new(3166, 3167), + Interval::new(3172, 3173), + Interval::new(3184, 3190), + Interval::new(3213, 3213), + Interval::new(3217, 3217), + Interval::new(3241, 3241), + Interval::new(3252, 3252), + Interval::new(3258, 3259), + Interval::new(3269, 3269), + Interval::new(3273, 3273), + Interval::new(3278, 3284), + Interval::new(3287, 3291), + Interval::new(3295, 3295), + Interval::new(3300, 3301), + Interval::new(3312, 3312), + Interval::new(3316, 3327), + Interval::new(3341, 3341), + Interval::new(3345, 3345), + Interval::new(3397, 3397), + Interval::new(3401, 3401), + Interval::new(3408, 3411), + Interval::new(3428, 3429), + Interval::new(3456, 3456), + Interval::new(3460, 3460), + Interval::new(3479, 3481), + Interval::new(3506, 3506), + Interval::new(3516, 3516), + Interval::new(3518, 3519), + Interval::new(3527, 3529), + Interval::new(3531, 3534), + Interval::new(3541, 3541), + Interval::new(3543, 3543), + Interval::new(3552, 3557), + Interval::new(3568, 3569), + Interval::new(3573, 3584), + Interval::new(3643, 3646), + Interval::new(3676, 3712), + Interval::new(3715, 3715), + Interval::new(3717, 3717), + Interval::new(3723, 3723), + Interval::new(3748, 3748), + Interval::new(3750, 3750), + Interval::new(3774, 3775), + Interval::new(3781, 3781), + Interval::new(3783, 3783), + Interval::new(3791, 3791), + Interval::new(3802, 3803), + Interval::new(3808, 3839), + Interval::new(3912, 3912), + Interval::new(3949, 3952), + Interval::new(3992, 3992), + Interval::new(4029, 4029), + Interval::new(4045, 4045), + Interval::new(4059, 4095), + Interval::new(4294, 4294), + Interval::new(4296, 4300), + Interval::new(4302, 4303), + Interval::new(4681, 4681), + Interval::new(4686, 4687), + Interval::new(4695, 4695), + Interval::new(4697, 4697), + Interval::new(4702, 4703), + Interval::new(4745, 4745), + Interval::new(4750, 4751), + Interval::new(4785, 4785), + Interval::new(4790, 4791), + Interval::new(4799, 4799), + Interval::new(4801, 4801), + Interval::new(4806, 4807), + Interval::new(4823, 4823), + Interval::new(4881, 4881), + Interval::new(4886, 4887), + Interval::new(4955, 4956), + Interval::new(4989, 4991), + Interval::new(5018, 5023), + Interval::new(5110, 5111), + Interval::new(5118, 5119), + Interval::new(5789, 5791), + Interval::new(5881, 5887), + Interval::new(5910, 5918), + Interval::new(5943, 5951), + Interval::new(5972, 5983), + Interval::new(5997, 5997), + Interval::new(6001, 6001), + Interval::new(6004, 6015), + Interval::new(6110, 6111), + Interval::new(6122, 6127), + Interval::new(6138, 6143), + Interval::new(6170, 6175), + Interval::new(6265, 6271), + Interval::new(6315, 6319), + Interval::new(6390, 6399), + Interval::new(6431, 6431), + Interval::new(6444, 6447), + Interval::new(6460, 6463), + Interval::new(6465, 6467), + Interval::new(6510, 6511), + Interval::new(6517, 6527), + Interval::new(6572, 6575), + Interval::new(6602, 6607), + Interval::new(6619, 6621), + Interval::new(6684, 6685), + Interval::new(6751, 6751), + Interval::new(6781, 6782), + Interval::new(6794, 6799), + Interval::new(6810, 6815), + Interval::new(6830, 6831), + Interval::new(6878, 6879), + Interval::new(6892, 6911), + Interval::new(6989, 6989), + Interval::new(7156, 7163), + Interval::new(7224, 7226), + Interval::new(7242, 7244), + Interval::new(7307, 7311), + Interval::new(7355, 7356), + Interval::new(7368, 7375), + Interval::new(7419, 7423), + Interval::new(7958, 7959), + Interval::new(7966, 7967), + Interval::new(8006, 8007), + Interval::new(8014, 8015), + Interval::new(8024, 8024), + Interval::new(8026, 8026), + Interval::new(8028, 8028), + Interval::new(8030, 8030), + Interval::new(8062, 8063), + Interval::new(8117, 8117), + Interval::new(8133, 8133), + Interval::new(8148, 8149), + Interval::new(8156, 8156), + Interval::new(8176, 8177), + Interval::new(8181, 8181), + Interval::new(8191, 8191), + Interval::new(8293, 8293), + Interval::new(8306, 8307), + Interval::new(8335, 8335), + Interval::new(8349, 8351), + Interval::new(8386, 8399), + Interval::new(8433, 8447), + Interval::new(8588, 8591), + Interval::new(9258, 9279), + Interval::new(9291, 9311), + Interval::new(11124, 11125), + Interval::new(11508, 11512), + Interval::new(11558, 11558), + Interval::new(11560, 11564), + Interval::new(11566, 11567), + Interval::new(11624, 11630), + Interval::new(11633, 11646), + Interval::new(11671, 11679), + Interval::new(11687, 11687), + Interval::new(11695, 11695), + Interval::new(11703, 11703), + Interval::new(11711, 11711), + Interval::new(11719, 11719), + Interval::new(11727, 11727), + Interval::new(11735, 11735), + Interval::new(11743, 11743), + Interval::new(11870, 11903), + Interval::new(11930, 11930), + Interval::new(12020, 12031), + Interval::new(12246, 12271), + Interval::new(12352, 12352), + Interval::new(12439, 12440), + Interval::new(12544, 12548), + Interval::new(12592, 12592), + Interval::new(12687, 12687), + Interval::new(12774, 12782), + Interval::new(12831, 12831), + Interval::new(42125, 42127), + Interval::new(42183, 42191), + Interval::new(42540, 42559), + Interval::new(42744, 42751), + Interval::new(42973, 42992), + Interval::new(43053, 43055), + Interval::new(43066, 43071), + Interval::new(43128, 43135), + Interval::new(43206, 43213), + Interval::new(43226, 43231), + Interval::new(43348, 43358), + Interval::new(43389, 43391), + Interval::new(43470, 43470), + Interval::new(43482, 43485), + Interval::new(43519, 43519), + Interval::new(43575, 43583), + Interval::new(43598, 43599), + Interval::new(43610, 43611), + Interval::new(43715, 43738), + Interval::new(43767, 43776), + Interval::new(43783, 43784), + Interval::new(43791, 43792), + Interval::new(43799, 43807), + Interval::new(43815, 43815), + Interval::new(43823, 43823), + Interval::new(43884, 43887), + Interval::new(44014, 44015), + Interval::new(44026, 44031), + Interval::new(55204, 55215), + Interval::new(55239, 55242), + Interval::new(55292, 55295), + Interval::new(64110, 64111), + Interval::new(64218, 64255), + Interval::new(64263, 64274), + Interval::new(64280, 64284), + Interval::new(64311, 64311), + Interval::new(64317, 64317), + Interval::new(64319, 64319), + Interval::new(64322, 64322), + Interval::new(64325, 64325), + Interval::new(64976, 65007), + Interval::new(65050, 65055), + Interval::new(65107, 65107), + Interval::new(65127, 65127), + Interval::new(65132, 65135), + Interval::new(65141, 65141), + Interval::new(65277, 65278), + Interval::new(65280, 65280), + Interval::new(65471, 65473), + Interval::new(65480, 65481), + Interval::new(65488, 65489), + Interval::new(65496, 65497), + Interval::new(65501, 65503), + Interval::new(65511, 65511), + Interval::new(65519, 65528), + Interval::new(65534, 65535), + Interval::new(65548, 65548), + Interval::new(65575, 65575), + Interval::new(65595, 65595), + Interval::new(65598, 65598), + Interval::new(65614, 65615), + Interval::new(65630, 65663), + Interval::new(65787, 65791), + Interval::new(65795, 65798), + Interval::new(65844, 65846), + Interval::new(65935, 65935), + Interval::new(65949, 65951), + Interval::new(65953, 65999), + Interval::new(66046, 66175), + Interval::new(66205, 66207), + Interval::new(66257, 66271), + Interval::new(66300, 66303), + Interval::new(66340, 66348), + Interval::new(66379, 66383), + Interval::new(66427, 66431), + Interval::new(66462, 66462), + Interval::new(66500, 66503), + Interval::new(66518, 66559), + Interval::new(66718, 66719), + Interval::new(66730, 66735), + Interval::new(66772, 66775), + Interval::new(66812, 66815), + Interval::new(66856, 66863), + Interval::new(66916, 66926), + Interval::new(66939, 66939), + Interval::new(66955, 66955), + Interval::new(66963, 66963), + Interval::new(66966, 66966), + Interval::new(66978, 66978), + Interval::new(66994, 66994), + Interval::new(67002, 67002), + Interval::new(67005, 67007), + Interval::new(67060, 67071), + Interval::new(67383, 67391), + Interval::new(67414, 67423), + Interval::new(67432, 67455), + Interval::new(67462, 67462), + Interval::new(67505, 67505), + Interval::new(67515, 67583), + Interval::new(67590, 67591), + Interval::new(67593, 67593), + Interval::new(67638, 67638), + Interval::new(67641, 67643), + Interval::new(67645, 67646), + Interval::new(67670, 67670), + Interval::new(67743, 67750), + Interval::new(67760, 67807), + Interval::new(67827, 67827), + Interval::new(67830, 67834), + Interval::new(67868, 67870), + Interval::new(67898, 67902), + Interval::new(67930, 67967), + Interval::new(68024, 68027), + Interval::new(68048, 68049), + Interval::new(68100, 68100), + Interval::new(68103, 68107), + Interval::new(68116, 68116), + Interval::new(68120, 68120), + Interval::new(68150, 68151), + Interval::new(68155, 68158), + Interval::new(68169, 68175), + Interval::new(68185, 68191), + Interval::new(68256, 68287), + Interval::new(68327, 68330), + Interval::new(68343, 68351), + Interval::new(68406, 68408), + Interval::new(68438, 68439), + Interval::new(68467, 68471), + Interval::new(68498, 68504), + Interval::new(68509, 68520), + Interval::new(68528, 68607), + Interval::new(68681, 68735), + Interval::new(68787, 68799), + Interval::new(68851, 68857), + Interval::new(68904, 68911), + Interval::new(68922, 68927), + Interval::new(68966, 68968), + Interval::new(68998, 69005), + Interval::new(69008, 69215), + Interval::new(69247, 69247), + Interval::new(69290, 69290), + Interval::new(69294, 69295), + Interval::new(69298, 69313), + Interval::new(69320, 69327), + Interval::new(69337, 69369), + Interval::new(69416, 69423), + Interval::new(69466, 69487), + Interval::new(69514, 69551), + Interval::new(69580, 69599), + Interval::new(69623, 69631), + Interval::new(69710, 69713), + Interval::new(69750, 69758), + Interval::new(69827, 69836), + Interval::new(69838, 69839), + Interval::new(69865, 69871), + Interval::new(69882, 69887), + Interval::new(69941, 69941), + Interval::new(69960, 69967), + Interval::new(70007, 70015), + Interval::new(70112, 70112), + Interval::new(70133, 70143), + Interval::new(70162, 70162), + Interval::new(70210, 70271), + Interval::new(70279, 70279), + Interval::new(70281, 70281), + Interval::new(70286, 70286), + Interval::new(70302, 70302), + Interval::new(70314, 70319), + Interval::new(70379, 70383), + Interval::new(70394, 70399), + Interval::new(70404, 70404), + Interval::new(70413, 70414), + Interval::new(70417, 70418), + Interval::new(70441, 70441), + Interval::new(70449, 70449), + Interval::new(70452, 70452), + Interval::new(70458, 70458), + Interval::new(70469, 70470), + Interval::new(70473, 70474), + Interval::new(70478, 70479), + Interval::new(70481, 70486), + Interval::new(70488, 70492), + Interval::new(70500, 70501), + Interval::new(70509, 70511), + Interval::new(70517, 70527), + Interval::new(70538, 70538), + Interval::new(70540, 70541), + Interval::new(70543, 70543), + Interval::new(70582, 70582), + Interval::new(70593, 70593), + Interval::new(70595, 70596), + Interval::new(70598, 70598), + Interval::new(70603, 70603), + Interval::new(70614, 70614), + Interval::new(70617, 70624), + Interval::new(70627, 70655), + Interval::new(70748, 70748), + Interval::new(70754, 70783), + Interval::new(70856, 70863), + Interval::new(70874, 71039), + Interval::new(71094, 71095), + Interval::new(71134, 71167), + Interval::new(71237, 71247), + Interval::new(71258, 71263), + Interval::new(71277, 71295), + Interval::new(71354, 71359), + Interval::new(71370, 71375), + Interval::new(71396, 71423), + Interval::new(71451, 71452), + Interval::new(71468, 71471), + Interval::new(71495, 71679), + Interval::new(71740, 71839), + Interval::new(71923, 71934), + Interval::new(71943, 71944), + Interval::new(71946, 71947), + Interval::new(71956, 71956), + Interval::new(71959, 71959), + Interval::new(71990, 71990), + Interval::new(71993, 71994), + Interval::new(72007, 72015), + Interval::new(72026, 72095), + Interval::new(72104, 72105), + Interval::new(72152, 72153), + Interval::new(72165, 72191), + Interval::new(72264, 72271), + Interval::new(72355, 72367), + Interval::new(72441, 72447), + Interval::new(72458, 72543), + Interval::new(72552, 72639), + Interval::new(72674, 72687), + Interval::new(72698, 72703), + Interval::new(72713, 72713), + Interval::new(72759, 72759), + Interval::new(72774, 72783), + Interval::new(72813, 72815), + Interval::new(72848, 72849), + Interval::new(72872, 72872), + Interval::new(72887, 72959), + Interval::new(72967, 72967), + Interval::new(72970, 72970), + Interval::new(73015, 73017), + Interval::new(73019, 73019), + Interval::new(73022, 73022), + Interval::new(73032, 73039), + Interval::new(73050, 73055), + Interval::new(73062, 73062), + Interval::new(73065, 73065), + Interval::new(73103, 73103), + Interval::new(73106, 73106), + Interval::new(73113, 73119), + Interval::new(73130, 73135), + Interval::new(73180, 73183), + Interval::new(73194, 73439), + Interval::new(73465, 73471), + Interval::new(73489, 73489), + Interval::new(73531, 73533), + Interval::new(73563, 73647), + Interval::new(73649, 73663), + Interval::new(73714, 73726), + Interval::new(74650, 74751), + Interval::new(74863, 74863), + Interval::new(74869, 74879), + Interval::new(75076, 77711), + Interval::new(77811, 77823), + Interval::new(78934, 78943), + Interval::new(82939, 82943), + Interval::new(83527, 90367), + Interval::new(90426, 92159), + Interval::new(92729, 92735), + Interval::new(92767, 92767), + Interval::new(92778, 92781), + Interval::new(92863, 92863), + Interval::new(92874, 92879), + Interval::new(92910, 92911), + Interval::new(92918, 92927), + Interval::new(92998, 93007), + Interval::new(93018, 93018), + Interval::new(93026, 93026), + Interval::new(93048, 93052), + Interval::new(93072, 93503), + Interval::new(93562, 93759), + Interval::new(93851, 93855), + Interval::new(93881, 93882), + Interval::new(93908, 93951), + Interval::new(94027, 94030), + Interval::new(94088, 94094), + Interval::new(94112, 94175), + Interval::new(94181, 94191), + Interval::new(94199, 94207), + Interval::new(101590, 101630), + Interval::new(101663, 101759), + Interval::new(101875, 110575), + Interval::new(110580, 110580), + Interval::new(110588, 110588), + Interval::new(110591, 110591), + Interval::new(110883, 110897), + Interval::new(110899, 110927), + Interval::new(110931, 110932), + Interval::new(110934, 110947), + Interval::new(110952, 110959), + Interval::new(111356, 113663), + Interval::new(113771, 113775), + Interval::new(113789, 113791), + Interval::new(113801, 113807), + Interval::new(113818, 113819), + Interval::new(113828, 117759), + Interval::new(118013, 118015), + Interval::new(118452, 118457), + Interval::new(118481, 118495), + Interval::new(118513, 118527), + Interval::new(118574, 118575), + Interval::new(118599, 118607), + Interval::new(118724, 118783), + Interval::new(119030, 119039), + Interval::new(119079, 119080), + Interval::new(119275, 119295), + Interval::new(119366, 119487), + Interval::new(119508, 119519), + Interval::new(119540, 119551), + Interval::new(119639, 119647), + Interval::new(119673, 119807), + Interval::new(119893, 119893), + Interval::new(119965, 119965), + Interval::new(119968, 119969), + Interval::new(119971, 119972), + Interval::new(119975, 119976), + Interval::new(119981, 119981), + Interval::new(119994, 119994), + Interval::new(119996, 119996), + Interval::new(120004, 120004), + Interval::new(120070, 120070), + Interval::new(120075, 120076), + Interval::new(120085, 120085), + Interval::new(120093, 120093), + Interval::new(120122, 120122), + Interval::new(120127, 120127), + Interval::new(120133, 120133), + Interval::new(120135, 120137), + Interval::new(120145, 120145), + Interval::new(120486, 120487), + Interval::new(120780, 120781), + Interval::new(121484, 121498), + Interval::new(121504, 121504), + Interval::new(121520, 122623), + Interval::new(122655, 122660), + Interval::new(122667, 122879), + Interval::new(122887, 122887), + Interval::new(122905, 122906), + Interval::new(122914, 122914), + Interval::new(122917, 122917), + Interval::new(122923, 122927), + Interval::new(122990, 123022), + Interval::new(123024, 123135), + Interval::new(123181, 123183), + Interval::new(123198, 123199), + Interval::new(123210, 123213), + Interval::new(123216, 123535), + Interval::new(123567, 123583), + Interval::new(123642, 123646), + Interval::new(123648, 124111), + Interval::new(124154, 124367), + Interval::new(124411, 124414), + Interval::new(124416, 124607), + Interval::new(124639, 124639), + Interval::new(124662, 124669), + Interval::new(124672, 124895), + Interval::new(124903, 124903), + Interval::new(124908, 124908), + Interval::new(124911, 124911), + Interval::new(124927, 124927), + Interval::new(125125, 125126), + Interval::new(125143, 125183), + Interval::new(125260, 125263), + Interval::new(125274, 125277), + Interval::new(125280, 126064), + Interval::new(126133, 126208), + Interval::new(126270, 126463), + Interval::new(126468, 126468), + Interval::new(126496, 126496), + Interval::new(126499, 126499), + Interval::new(126501, 126502), + Interval::new(126504, 126504), + Interval::new(126515, 126515), + Interval::new(126520, 126520), + Interval::new(126522, 126522), + Interval::new(126524, 126529), + Interval::new(126531, 126534), + Interval::new(126536, 126536), + Interval::new(126538, 126538), + Interval::new(126540, 126540), + Interval::new(126544, 126544), + Interval::new(126547, 126547), + Interval::new(126549, 126550), + Interval::new(126552, 126552), + Interval::new(126554, 126554), + Interval::new(126556, 126556), + Interval::new(126558, 126558), + Interval::new(126560, 126560), + Interval::new(126563, 126563), + Interval::new(126565, 126566), + Interval::new(126571, 126571), + Interval::new(126579, 126579), + Interval::new(126584, 126584), + Interval::new(126589, 126589), + Interval::new(126591, 126591), + Interval::new(126602, 126602), + Interval::new(126620, 126624), + Interval::new(126628, 126628), + Interval::new(126634, 126634), + Interval::new(126652, 126703), + Interval::new(126706, 126975), + Interval::new(127020, 127023), + Interval::new(127124, 127135), + Interval::new(127151, 127152), + Interval::new(127168, 127168), + Interval::new(127184, 127184), + Interval::new(127222, 127231), + Interval::new(127406, 127461), + Interval::new(127491, 127503), + Interval::new(127548, 127551), + Interval::new(127561, 127567), + Interval::new(127570, 127583), + Interval::new(127590, 127743), + Interval::new(128729, 128731), + Interval::new(128749, 128751), + Interval::new(128765, 128767), + Interval::new(128986, 128991), + Interval::new(129004, 129007), + Interval::new(129009, 129023), + Interval::new(129036, 129039), + Interval::new(129096, 129103), + Interval::new(129114, 129119), + Interval::new(129160, 129167), + Interval::new(129198, 129199), + Interval::new(129212, 129215), + Interval::new(129218, 129231), + Interval::new(129241, 129279), + Interval::new(129624, 129631), + Interval::new(129646, 129647), + Interval::new(129661, 129663), + Interval::new(129675, 129677), + Interval::new(129735, 129735), + Interval::new(129737, 129740), + Interval::new(129757, 129758), + Interval::new(129771, 129774), + Interval::new(129785, 129791), + Interval::new(129939, 129939), + Interval::new(130043, 131071), + Interval::new(173792, 173823), + Interval::new(178206, 178207), + Interval::new(183982, 183983), + Interval::new(191457, 191471), + Interval::new(192094, 194559), + Interval::new(195102, 196607), + Interval::new(201547, 201551), + Interval::new(210042, 917504), + Interval::new(917506, 917535), + Interval::new(917632, 917759), + Interval::new(918000, 983039), + Interval::new(1048574, 1048575), + Interval::new(1114110, 1114111), +]; + +/// Return the code point ranges of the 'Unassigned' Unicode property. +pub(crate) fn unassigned_ranges() -> &'static [Interval] { + &UNASSIGNED +} + +const UPPERCASE_LETTER: [Interval; 655] = [ + Interval::new(65, 90), + Interval::new(192, 214), + Interval::new(216, 222), + Interval::new(256, 256), + Interval::new(258, 258), + Interval::new(260, 260), + Interval::new(262, 262), + Interval::new(264, 264), + Interval::new(266, 266), + Interval::new(268, 268), + Interval::new(270, 270), + Interval::new(272, 272), + Interval::new(274, 274), + Interval::new(276, 276), + Interval::new(278, 278), + Interval::new(280, 280), + Interval::new(282, 282), + Interval::new(284, 284), + Interval::new(286, 286), + Interval::new(288, 288), + Interval::new(290, 290), + Interval::new(292, 292), + Interval::new(294, 294), + Interval::new(296, 296), + Interval::new(298, 298), + Interval::new(300, 300), + Interval::new(302, 302), + Interval::new(304, 304), + Interval::new(306, 306), + Interval::new(308, 308), + Interval::new(310, 310), + Interval::new(313, 313), + Interval::new(315, 315), + Interval::new(317, 317), + Interval::new(319, 319), + Interval::new(321, 321), + Interval::new(323, 323), + Interval::new(325, 325), + Interval::new(327, 327), + Interval::new(330, 330), + Interval::new(332, 332), + Interval::new(334, 334), + Interval::new(336, 336), + Interval::new(338, 338), + Interval::new(340, 340), + Interval::new(342, 342), + Interval::new(344, 344), + Interval::new(346, 346), + Interval::new(348, 348), + Interval::new(350, 350), + Interval::new(352, 352), + Interval::new(354, 354), + Interval::new(356, 356), + Interval::new(358, 358), + Interval::new(360, 360), + Interval::new(362, 362), + Interval::new(364, 364), + Interval::new(366, 366), + Interval::new(368, 368), + Interval::new(370, 370), + Interval::new(372, 372), + Interval::new(374, 374), + Interval::new(376, 377), + Interval::new(379, 379), + Interval::new(381, 381), + Interval::new(385, 386), + Interval::new(388, 388), + Interval::new(390, 391), + Interval::new(393, 395), + Interval::new(398, 401), + Interval::new(403, 404), + Interval::new(406, 408), + Interval::new(412, 413), + Interval::new(415, 416), + Interval::new(418, 418), + Interval::new(420, 420), + Interval::new(422, 423), + Interval::new(425, 425), + Interval::new(428, 428), + Interval::new(430, 431), + Interval::new(433, 435), + Interval::new(437, 437), + Interval::new(439, 440), + Interval::new(444, 444), + Interval::new(452, 452), + Interval::new(455, 455), + Interval::new(458, 458), + Interval::new(461, 461), + Interval::new(463, 463), + Interval::new(465, 465), + Interval::new(467, 467), + Interval::new(469, 469), + Interval::new(471, 471), + Interval::new(473, 473), + Interval::new(475, 475), + Interval::new(478, 478), + Interval::new(480, 480), + Interval::new(482, 482), + Interval::new(484, 484), + Interval::new(486, 486), + Interval::new(488, 488), + Interval::new(490, 490), + Interval::new(492, 492), + Interval::new(494, 494), + Interval::new(497, 497), + Interval::new(500, 500), + Interval::new(502, 504), + Interval::new(506, 506), + Interval::new(508, 508), + Interval::new(510, 510), + Interval::new(512, 512), + Interval::new(514, 514), + Interval::new(516, 516), + Interval::new(518, 518), + Interval::new(520, 520), + Interval::new(522, 522), + Interval::new(524, 524), + Interval::new(526, 526), + Interval::new(528, 528), + Interval::new(530, 530), + Interval::new(532, 532), + Interval::new(534, 534), + Interval::new(536, 536), + Interval::new(538, 538), + Interval::new(540, 540), + Interval::new(542, 542), + Interval::new(544, 544), + Interval::new(546, 546), + Interval::new(548, 548), + Interval::new(550, 550), + Interval::new(552, 552), + Interval::new(554, 554), + Interval::new(556, 556), + Interval::new(558, 558), + Interval::new(560, 560), + Interval::new(562, 562), + Interval::new(570, 571), + Interval::new(573, 574), + Interval::new(577, 577), + Interval::new(579, 582), + Interval::new(584, 584), + Interval::new(586, 586), + Interval::new(588, 588), + Interval::new(590, 590), + Interval::new(880, 880), + Interval::new(882, 882), + Interval::new(886, 886), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 911), + Interval::new(913, 929), + Interval::new(931, 939), + Interval::new(975, 975), + Interval::new(978, 980), + Interval::new(984, 984), + Interval::new(986, 986), + Interval::new(988, 988), + Interval::new(990, 990), + Interval::new(992, 992), + Interval::new(994, 994), + Interval::new(996, 996), + Interval::new(998, 998), + Interval::new(1000, 1000), + Interval::new(1002, 1002), + Interval::new(1004, 1004), + Interval::new(1006, 1006), + Interval::new(1012, 1012), + Interval::new(1015, 1015), + Interval::new(1017, 1018), + Interval::new(1021, 1071), + Interval::new(1120, 1120), + Interval::new(1122, 1122), + Interval::new(1124, 1124), + Interval::new(1126, 1126), + Interval::new(1128, 1128), + Interval::new(1130, 1130), + Interval::new(1132, 1132), + Interval::new(1134, 1134), + Interval::new(1136, 1136), + Interval::new(1138, 1138), + Interval::new(1140, 1140), + Interval::new(1142, 1142), + Interval::new(1144, 1144), + Interval::new(1146, 1146), + Interval::new(1148, 1148), + Interval::new(1150, 1150), + Interval::new(1152, 1152), + Interval::new(1162, 1162), + Interval::new(1164, 1164), + Interval::new(1166, 1166), + Interval::new(1168, 1168), + Interval::new(1170, 1170), + Interval::new(1172, 1172), + Interval::new(1174, 1174), + Interval::new(1176, 1176), + Interval::new(1178, 1178), + Interval::new(1180, 1180), + Interval::new(1182, 1182), + Interval::new(1184, 1184), + Interval::new(1186, 1186), + Interval::new(1188, 1188), + Interval::new(1190, 1190), + Interval::new(1192, 1192), + Interval::new(1194, 1194), + Interval::new(1196, 1196), + Interval::new(1198, 1198), + Interval::new(1200, 1200), + Interval::new(1202, 1202), + Interval::new(1204, 1204), + Interval::new(1206, 1206), + Interval::new(1208, 1208), + Interval::new(1210, 1210), + Interval::new(1212, 1212), + Interval::new(1214, 1214), + Interval::new(1216, 1217), + Interval::new(1219, 1219), + Interval::new(1221, 1221), + Interval::new(1223, 1223), + Interval::new(1225, 1225), + Interval::new(1227, 1227), + Interval::new(1229, 1229), + Interval::new(1232, 1232), + Interval::new(1234, 1234), + Interval::new(1236, 1236), + Interval::new(1238, 1238), + Interval::new(1240, 1240), + Interval::new(1242, 1242), + Interval::new(1244, 1244), + Interval::new(1246, 1246), + Interval::new(1248, 1248), + Interval::new(1250, 1250), + Interval::new(1252, 1252), + Interval::new(1254, 1254), + Interval::new(1256, 1256), + Interval::new(1258, 1258), + Interval::new(1260, 1260), + Interval::new(1262, 1262), + Interval::new(1264, 1264), + Interval::new(1266, 1266), + Interval::new(1268, 1268), + Interval::new(1270, 1270), + Interval::new(1272, 1272), + Interval::new(1274, 1274), + Interval::new(1276, 1276), + Interval::new(1278, 1278), + Interval::new(1280, 1280), + Interval::new(1282, 1282), + Interval::new(1284, 1284), + Interval::new(1286, 1286), + Interval::new(1288, 1288), + Interval::new(1290, 1290), + Interval::new(1292, 1292), + Interval::new(1294, 1294), + Interval::new(1296, 1296), + Interval::new(1298, 1298), + Interval::new(1300, 1300), + Interval::new(1302, 1302), + Interval::new(1304, 1304), + Interval::new(1306, 1306), + Interval::new(1308, 1308), + Interval::new(1310, 1310), + Interval::new(1312, 1312), + Interval::new(1314, 1314), + Interval::new(1316, 1316), + Interval::new(1318, 1318), + Interval::new(1320, 1320), + Interval::new(1322, 1322), + Interval::new(1324, 1324), + Interval::new(1326, 1326), + Interval::new(1329, 1366), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(5024, 5109), + Interval::new(7305, 7305), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7680, 7680), + Interval::new(7682, 7682), + Interval::new(7684, 7684), + Interval::new(7686, 7686), + Interval::new(7688, 7688), + Interval::new(7690, 7690), + Interval::new(7692, 7692), + Interval::new(7694, 7694), + Interval::new(7696, 7696), + Interval::new(7698, 7698), + Interval::new(7700, 7700), + Interval::new(7702, 7702), + Interval::new(7704, 7704), + Interval::new(7706, 7706), + Interval::new(7708, 7708), + Interval::new(7710, 7710), + Interval::new(7712, 7712), + Interval::new(7714, 7714), + Interval::new(7716, 7716), + Interval::new(7718, 7718), + Interval::new(7720, 7720), + Interval::new(7722, 7722), + Interval::new(7724, 7724), + Interval::new(7726, 7726), + Interval::new(7728, 7728), + Interval::new(7730, 7730), + Interval::new(7732, 7732), + Interval::new(7734, 7734), + Interval::new(7736, 7736), + Interval::new(7738, 7738), + Interval::new(7740, 7740), + Interval::new(7742, 7742), + Interval::new(7744, 7744), + Interval::new(7746, 7746), + Interval::new(7748, 7748), + Interval::new(7750, 7750), + Interval::new(7752, 7752), + Interval::new(7754, 7754), + Interval::new(7756, 7756), + Interval::new(7758, 7758), + Interval::new(7760, 7760), + Interval::new(7762, 7762), + Interval::new(7764, 7764), + Interval::new(7766, 7766), + Interval::new(7768, 7768), + Interval::new(7770, 7770), + Interval::new(7772, 7772), + Interval::new(7774, 7774), + Interval::new(7776, 7776), + Interval::new(7778, 7778), + Interval::new(7780, 7780), + Interval::new(7782, 7782), + Interval::new(7784, 7784), + Interval::new(7786, 7786), + Interval::new(7788, 7788), + Interval::new(7790, 7790), + Interval::new(7792, 7792), + Interval::new(7794, 7794), + Interval::new(7796, 7796), + Interval::new(7798, 7798), + Interval::new(7800, 7800), + Interval::new(7802, 7802), + Interval::new(7804, 7804), + Interval::new(7806, 7806), + Interval::new(7808, 7808), + Interval::new(7810, 7810), + Interval::new(7812, 7812), + Interval::new(7814, 7814), + Interval::new(7816, 7816), + Interval::new(7818, 7818), + Interval::new(7820, 7820), + Interval::new(7822, 7822), + Interval::new(7824, 7824), + Interval::new(7826, 7826), + Interval::new(7828, 7828), + Interval::new(7838, 7838), + Interval::new(7840, 7840), + Interval::new(7842, 7842), + Interval::new(7844, 7844), + Interval::new(7846, 7846), + Interval::new(7848, 7848), + Interval::new(7850, 7850), + Interval::new(7852, 7852), + Interval::new(7854, 7854), + Interval::new(7856, 7856), + Interval::new(7858, 7858), + Interval::new(7860, 7860), + Interval::new(7862, 7862), + Interval::new(7864, 7864), + Interval::new(7866, 7866), + Interval::new(7868, 7868), + Interval::new(7870, 7870), + Interval::new(7872, 7872), + Interval::new(7874, 7874), + Interval::new(7876, 7876), + Interval::new(7878, 7878), + Interval::new(7880, 7880), + Interval::new(7882, 7882), + Interval::new(7884, 7884), + Interval::new(7886, 7886), + Interval::new(7888, 7888), + Interval::new(7890, 7890), + Interval::new(7892, 7892), + Interval::new(7894, 7894), + Interval::new(7896, 7896), + Interval::new(7898, 7898), + Interval::new(7900, 7900), + Interval::new(7902, 7902), + Interval::new(7904, 7904), + Interval::new(7906, 7906), + Interval::new(7908, 7908), + Interval::new(7910, 7910), + Interval::new(7912, 7912), + Interval::new(7914, 7914), + Interval::new(7916, 7916), + Interval::new(7918, 7918), + Interval::new(7920, 7920), + Interval::new(7922, 7922), + Interval::new(7924, 7924), + Interval::new(7926, 7926), + Interval::new(7928, 7928), + Interval::new(7930, 7930), + Interval::new(7932, 7932), + Interval::new(7934, 7934), + Interval::new(7944, 7951), + Interval::new(7960, 7965), + Interval::new(7976, 7983), + Interval::new(7992, 7999), + Interval::new(8008, 8013), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8031), + Interval::new(8040, 8047), + Interval::new(8120, 8123), + Interval::new(8136, 8139), + Interval::new(8152, 8155), + Interval::new(8168, 8172), + Interval::new(8184, 8187), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8459, 8461), + Interval::new(8464, 8466), + Interval::new(8469, 8469), + Interval::new(8473, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8496, 8499), + Interval::new(8510, 8511), + Interval::new(8517, 8517), + Interval::new(8579, 8579), + Interval::new(11264, 11311), + Interval::new(11360, 11360), + Interval::new(11362, 11364), + Interval::new(11367, 11367), + Interval::new(11369, 11369), + Interval::new(11371, 11371), + Interval::new(11373, 11376), + Interval::new(11378, 11378), + Interval::new(11381, 11381), + Interval::new(11390, 11392), + Interval::new(11394, 11394), + Interval::new(11396, 11396), + Interval::new(11398, 11398), + Interval::new(11400, 11400), + Interval::new(11402, 11402), + Interval::new(11404, 11404), + Interval::new(11406, 11406), + Interval::new(11408, 11408), + Interval::new(11410, 11410), + Interval::new(11412, 11412), + Interval::new(11414, 11414), + Interval::new(11416, 11416), + Interval::new(11418, 11418), + Interval::new(11420, 11420), + Interval::new(11422, 11422), + Interval::new(11424, 11424), + Interval::new(11426, 11426), + Interval::new(11428, 11428), + Interval::new(11430, 11430), + Interval::new(11432, 11432), + Interval::new(11434, 11434), + Interval::new(11436, 11436), + Interval::new(11438, 11438), + Interval::new(11440, 11440), + Interval::new(11442, 11442), + Interval::new(11444, 11444), + Interval::new(11446, 11446), + Interval::new(11448, 11448), + Interval::new(11450, 11450), + Interval::new(11452, 11452), + Interval::new(11454, 11454), + Interval::new(11456, 11456), + Interval::new(11458, 11458), + Interval::new(11460, 11460), + Interval::new(11462, 11462), + Interval::new(11464, 11464), + Interval::new(11466, 11466), + Interval::new(11468, 11468), + Interval::new(11470, 11470), + Interval::new(11472, 11472), + Interval::new(11474, 11474), + Interval::new(11476, 11476), + Interval::new(11478, 11478), + Interval::new(11480, 11480), + Interval::new(11482, 11482), + Interval::new(11484, 11484), + Interval::new(11486, 11486), + Interval::new(11488, 11488), + Interval::new(11490, 11490), + Interval::new(11499, 11499), + Interval::new(11501, 11501), + Interval::new(11506, 11506), + Interval::new(42560, 42560), + Interval::new(42562, 42562), + Interval::new(42564, 42564), + Interval::new(42566, 42566), + Interval::new(42568, 42568), + Interval::new(42570, 42570), + Interval::new(42572, 42572), + Interval::new(42574, 42574), + Interval::new(42576, 42576), + Interval::new(42578, 42578), + Interval::new(42580, 42580), + Interval::new(42582, 42582), + Interval::new(42584, 42584), + Interval::new(42586, 42586), + Interval::new(42588, 42588), + Interval::new(42590, 42590), + Interval::new(42592, 42592), + Interval::new(42594, 42594), + Interval::new(42596, 42596), + Interval::new(42598, 42598), + Interval::new(42600, 42600), + Interval::new(42602, 42602), + Interval::new(42604, 42604), + Interval::new(42624, 42624), + Interval::new(42626, 42626), + Interval::new(42628, 42628), + Interval::new(42630, 42630), + Interval::new(42632, 42632), + Interval::new(42634, 42634), + Interval::new(42636, 42636), + Interval::new(42638, 42638), + Interval::new(42640, 42640), + Interval::new(42642, 42642), + Interval::new(42644, 42644), + Interval::new(42646, 42646), + Interval::new(42648, 42648), + Interval::new(42650, 42650), + Interval::new(42786, 42786), + Interval::new(42788, 42788), + Interval::new(42790, 42790), + Interval::new(42792, 42792), + Interval::new(42794, 42794), + Interval::new(42796, 42796), + Interval::new(42798, 42798), + Interval::new(42802, 42802), + Interval::new(42804, 42804), + Interval::new(42806, 42806), + Interval::new(42808, 42808), + Interval::new(42810, 42810), + Interval::new(42812, 42812), + Interval::new(42814, 42814), + Interval::new(42816, 42816), + Interval::new(42818, 42818), + Interval::new(42820, 42820), + Interval::new(42822, 42822), + Interval::new(42824, 42824), + Interval::new(42826, 42826), + Interval::new(42828, 42828), + Interval::new(42830, 42830), + Interval::new(42832, 42832), + Interval::new(42834, 42834), + Interval::new(42836, 42836), + Interval::new(42838, 42838), + Interval::new(42840, 42840), + Interval::new(42842, 42842), + Interval::new(42844, 42844), + Interval::new(42846, 42846), + Interval::new(42848, 42848), + Interval::new(42850, 42850), + Interval::new(42852, 42852), + Interval::new(42854, 42854), + Interval::new(42856, 42856), + Interval::new(42858, 42858), + Interval::new(42860, 42860), + Interval::new(42862, 42862), + Interval::new(42873, 42873), + Interval::new(42875, 42875), + Interval::new(42877, 42878), + Interval::new(42880, 42880), + Interval::new(42882, 42882), + Interval::new(42884, 42884), + Interval::new(42886, 42886), + Interval::new(42891, 42891), + Interval::new(42893, 42893), + Interval::new(42896, 42896), + Interval::new(42898, 42898), + Interval::new(42902, 42902), + Interval::new(42904, 42904), + Interval::new(42906, 42906), + Interval::new(42908, 42908), + Interval::new(42910, 42910), + Interval::new(42912, 42912), + Interval::new(42914, 42914), + Interval::new(42916, 42916), + Interval::new(42918, 42918), + Interval::new(42920, 42920), + Interval::new(42922, 42926), + Interval::new(42928, 42932), + Interval::new(42934, 42934), + Interval::new(42936, 42936), + Interval::new(42938, 42938), + Interval::new(42940, 42940), + Interval::new(42942, 42942), + Interval::new(42944, 42944), + Interval::new(42946, 42946), + Interval::new(42948, 42951), + Interval::new(42953, 42953), + Interval::new(42955, 42956), + Interval::new(42958, 42958), + Interval::new(42960, 42960), + Interval::new(42962, 42962), + Interval::new(42964, 42964), + Interval::new(42966, 42966), + Interval::new(42968, 42968), + Interval::new(42970, 42970), + Interval::new(42972, 42972), + Interval::new(42997, 42997), + Interval::new(65313, 65338), + Interval::new(66560, 66599), + Interval::new(66736, 66771), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(68736, 68786), + Interval::new(68944, 68965), + Interval::new(71840, 71871), + Interval::new(93760, 93791), + Interval::new(93856, 93880), + Interval::new(119808, 119833), + Interval::new(119860, 119885), + Interval::new(119912, 119937), + Interval::new(119964, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119989), + Interval::new(120016, 120041), + Interval::new(120068, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120120, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120172, 120197), + Interval::new(120224, 120249), + Interval::new(120276, 120301), + Interval::new(120328, 120353), + Interval::new(120380, 120405), + Interval::new(120432, 120457), + Interval::new(120488, 120512), + Interval::new(120546, 120570), + Interval::new(120604, 120628), + Interval::new(120662, 120686), + Interval::new(120720, 120744), + Interval::new(120778, 120778), + Interval::new(125184, 125217), +]; + +/// Return the code point ranges of the 'Uppercase_Letter' Unicode property. +pub(crate) fn uppercase_letter_ranges() -> &'static [Interval] { + &UPPERCASE_LETTER +} + +const CASED_LETTER: [Interval; 144] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(181, 181), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 442), + Interval::new(444, 447), + Interval::new(452, 659), + Interval::new(662, 687), + Interval::new(880, 883), + Interval::new(886, 887), + Interval::new(891, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1376, 1416), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4349, 4351), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7424, 7467), + Interval::new(7531, 7543), + Interval::new(7545, 7578), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8473, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8495, 8500), + Interval::new(8505, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8579, 8580), + Interval::new(11264, 11387), + Interval::new(11390, 11492), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(42560, 42605), + Interval::new(42624, 42651), + Interval::new(42786, 42863), + Interval::new(42865, 42887), + Interval::new(42891, 42894), + Interval::new(42896, 42972), + Interval::new(42997, 42998), + Interval::new(43002, 43002), + Interval::new(43824, 43866), + Interval::new(43872, 43880), + Interval::new(43888, 43967), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(66560, 66639), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68944, 68965), + Interval::new(68976, 68997), + Interval::new(71840, 71903), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(122624, 122633), + Interval::new(122635, 122654), + Interval::new(122661, 122666), + Interval::new(125184, 125251), +]; + +/// Return the code point ranges of the 'Cased_Letter' Unicode property. +pub(crate) fn cased_letter_ranges() -> &'static [Interval] { + &CASED_LETTER +} + +const OTHER: [Interval; 741] = [ + Interval::new(0, 31), + Interval::new(127, 159), + Interval::new(173, 173), + Interval::new(888, 889), + Interval::new(896, 899), + Interval::new(907, 907), + Interval::new(909, 909), + Interval::new(930, 930), + Interval::new(1328, 1328), + Interval::new(1367, 1368), + Interval::new(1419, 1420), + Interval::new(1424, 1424), + Interval::new(1480, 1487), + Interval::new(1515, 1518), + Interval::new(1525, 1541), + Interval::new(1564, 1564), + Interval::new(1757, 1757), + Interval::new(1806, 1807), + Interval::new(1867, 1868), + Interval::new(1970, 1983), + Interval::new(2043, 2044), + Interval::new(2094, 2095), + Interval::new(2111, 2111), + Interval::new(2140, 2141), + Interval::new(2143, 2143), + Interval::new(2155, 2159), + Interval::new(2192, 2198), + Interval::new(2274, 2274), + Interval::new(2436, 2436), + Interval::new(2445, 2446), + Interval::new(2449, 2450), + Interval::new(2473, 2473), + Interval::new(2481, 2481), + Interval::new(2483, 2485), + Interval::new(2490, 2491), + Interval::new(2501, 2502), + Interval::new(2505, 2506), + Interval::new(2511, 2518), + Interval::new(2520, 2523), + Interval::new(2526, 2526), + Interval::new(2532, 2533), + Interval::new(2559, 2560), + Interval::new(2564, 2564), + Interval::new(2571, 2574), + Interval::new(2577, 2578), + Interval::new(2601, 2601), + Interval::new(2609, 2609), + Interval::new(2612, 2612), + Interval::new(2615, 2615), + Interval::new(2618, 2619), + Interval::new(2621, 2621), + Interval::new(2627, 2630), + Interval::new(2633, 2634), + Interval::new(2638, 2640), + Interval::new(2642, 2648), + Interval::new(2653, 2653), + Interval::new(2655, 2661), + Interval::new(2679, 2688), + Interval::new(2692, 2692), + Interval::new(2702, 2702), + Interval::new(2706, 2706), + Interval::new(2729, 2729), + Interval::new(2737, 2737), + Interval::new(2740, 2740), + Interval::new(2746, 2747), + Interval::new(2758, 2758), + Interval::new(2762, 2762), + Interval::new(2766, 2767), + Interval::new(2769, 2783), + Interval::new(2788, 2789), + Interval::new(2802, 2808), + Interval::new(2816, 2816), + Interval::new(2820, 2820), + Interval::new(2829, 2830), + Interval::new(2833, 2834), + Interval::new(2857, 2857), + Interval::new(2865, 2865), + Interval::new(2868, 2868), + Interval::new(2874, 2875), + Interval::new(2885, 2886), + Interval::new(2889, 2890), + Interval::new(2894, 2900), + Interval::new(2904, 2907), + Interval::new(2910, 2910), + Interval::new(2916, 2917), + Interval::new(2936, 2945), + Interval::new(2948, 2948), + Interval::new(2955, 2957), + Interval::new(2961, 2961), + Interval::new(2966, 2968), + Interval::new(2971, 2971), + Interval::new(2973, 2973), + Interval::new(2976, 2978), + Interval::new(2981, 2983), + Interval::new(2987, 2989), + Interval::new(3002, 3005), + Interval::new(3011, 3013), + Interval::new(3017, 3017), + Interval::new(3022, 3023), + Interval::new(3025, 3030), + Interval::new(3032, 3045), + Interval::new(3067, 3071), + Interval::new(3085, 3085), + Interval::new(3089, 3089), + Interval::new(3113, 3113), + Interval::new(3130, 3131), + Interval::new(3141, 3141), + Interval::new(3145, 3145), + Interval::new(3150, 3156), + Interval::new(3159, 3159), + Interval::new(3163, 3163), + Interval::new(3166, 3167), + Interval::new(3172, 3173), + Interval::new(3184, 3190), + Interval::new(3213, 3213), + Interval::new(3217, 3217), + Interval::new(3241, 3241), + Interval::new(3252, 3252), + Interval::new(3258, 3259), + Interval::new(3269, 3269), + Interval::new(3273, 3273), + Interval::new(3278, 3284), + Interval::new(3287, 3291), + Interval::new(3295, 3295), + Interval::new(3300, 3301), + Interval::new(3312, 3312), + Interval::new(3316, 3327), + Interval::new(3341, 3341), + Interval::new(3345, 3345), + Interval::new(3397, 3397), + Interval::new(3401, 3401), + Interval::new(3408, 3411), + Interval::new(3428, 3429), + Interval::new(3456, 3456), + Interval::new(3460, 3460), + Interval::new(3479, 3481), + Interval::new(3506, 3506), + Interval::new(3516, 3516), + Interval::new(3518, 3519), + Interval::new(3527, 3529), + Interval::new(3531, 3534), + Interval::new(3541, 3541), + Interval::new(3543, 3543), + Interval::new(3552, 3557), + Interval::new(3568, 3569), + Interval::new(3573, 3584), + Interval::new(3643, 3646), + Interval::new(3676, 3712), + Interval::new(3715, 3715), + Interval::new(3717, 3717), + Interval::new(3723, 3723), + Interval::new(3748, 3748), + Interval::new(3750, 3750), + Interval::new(3774, 3775), + Interval::new(3781, 3781), + Interval::new(3783, 3783), + Interval::new(3791, 3791), + Interval::new(3802, 3803), + Interval::new(3808, 3839), + Interval::new(3912, 3912), + Interval::new(3949, 3952), + Interval::new(3992, 3992), + Interval::new(4029, 4029), + Interval::new(4045, 4045), + Interval::new(4059, 4095), + Interval::new(4294, 4294), + Interval::new(4296, 4300), + Interval::new(4302, 4303), + Interval::new(4681, 4681), + Interval::new(4686, 4687), + Interval::new(4695, 4695), + Interval::new(4697, 4697), + Interval::new(4702, 4703), + Interval::new(4745, 4745), + Interval::new(4750, 4751), + Interval::new(4785, 4785), + Interval::new(4790, 4791), + Interval::new(4799, 4799), + Interval::new(4801, 4801), + Interval::new(4806, 4807), + Interval::new(4823, 4823), + Interval::new(4881, 4881), + Interval::new(4886, 4887), + Interval::new(4955, 4956), + Interval::new(4989, 4991), + Interval::new(5018, 5023), + Interval::new(5110, 5111), + Interval::new(5118, 5119), + Interval::new(5789, 5791), + Interval::new(5881, 5887), + Interval::new(5910, 5918), + Interval::new(5943, 5951), + Interval::new(5972, 5983), + Interval::new(5997, 5997), + Interval::new(6001, 6001), + Interval::new(6004, 6015), + Interval::new(6110, 6111), + Interval::new(6122, 6127), + Interval::new(6138, 6143), + Interval::new(6158, 6158), + Interval::new(6170, 6175), + Interval::new(6265, 6271), + Interval::new(6315, 6319), + Interval::new(6390, 6399), + Interval::new(6431, 6431), + Interval::new(6444, 6447), + Interval::new(6460, 6463), + Interval::new(6465, 6467), + Interval::new(6510, 6511), + Interval::new(6517, 6527), + Interval::new(6572, 6575), + Interval::new(6602, 6607), + Interval::new(6619, 6621), + Interval::new(6684, 6685), + Interval::new(6751, 6751), + Interval::new(6781, 6782), + Interval::new(6794, 6799), + Interval::new(6810, 6815), + Interval::new(6830, 6831), + Interval::new(6878, 6879), + Interval::new(6892, 6911), + Interval::new(6989, 6989), + Interval::new(7156, 7163), + Interval::new(7224, 7226), + Interval::new(7242, 7244), + Interval::new(7307, 7311), + Interval::new(7355, 7356), + Interval::new(7368, 7375), + Interval::new(7419, 7423), + Interval::new(7958, 7959), + Interval::new(7966, 7967), + Interval::new(8006, 8007), + Interval::new(8014, 8015), + Interval::new(8024, 8024), + Interval::new(8026, 8026), + Interval::new(8028, 8028), + Interval::new(8030, 8030), + Interval::new(8062, 8063), + Interval::new(8117, 8117), + Interval::new(8133, 8133), + Interval::new(8148, 8149), + Interval::new(8156, 8156), + Interval::new(8176, 8177), + Interval::new(8181, 8181), + Interval::new(8191, 8191), + Interval::new(8203, 8207), + Interval::new(8234, 8238), + Interval::new(8288, 8303), + Interval::new(8306, 8307), + Interval::new(8335, 8335), + Interval::new(8349, 8351), + Interval::new(8386, 8399), + Interval::new(8433, 8447), + Interval::new(8588, 8591), + Interval::new(9258, 9279), + Interval::new(9291, 9311), + Interval::new(11124, 11125), + Interval::new(11508, 11512), + Interval::new(11558, 11558), + Interval::new(11560, 11564), + Interval::new(11566, 11567), + Interval::new(11624, 11630), + Interval::new(11633, 11646), + Interval::new(11671, 11679), + Interval::new(11687, 11687), + Interval::new(11695, 11695), + Interval::new(11703, 11703), + Interval::new(11711, 11711), + Interval::new(11719, 11719), + Interval::new(11727, 11727), + Interval::new(11735, 11735), + Interval::new(11743, 11743), + Interval::new(11870, 11903), + Interval::new(11930, 11930), + Interval::new(12020, 12031), + Interval::new(12246, 12271), + Interval::new(12352, 12352), + Interval::new(12439, 12440), + Interval::new(12544, 12548), + Interval::new(12592, 12592), + Interval::new(12687, 12687), + Interval::new(12774, 12782), + Interval::new(12831, 12831), + Interval::new(42125, 42127), + Interval::new(42183, 42191), + Interval::new(42540, 42559), + Interval::new(42744, 42751), + Interval::new(42973, 42992), + Interval::new(43053, 43055), + Interval::new(43066, 43071), + Interval::new(43128, 43135), + Interval::new(43206, 43213), + Interval::new(43226, 43231), + Interval::new(43348, 43358), + Interval::new(43389, 43391), + Interval::new(43470, 43470), + Interval::new(43482, 43485), + Interval::new(43519, 43519), + Interval::new(43575, 43583), + Interval::new(43598, 43599), + Interval::new(43610, 43611), + Interval::new(43715, 43738), + Interval::new(43767, 43776), + Interval::new(43783, 43784), + Interval::new(43791, 43792), + Interval::new(43799, 43807), + Interval::new(43815, 43815), + Interval::new(43823, 43823), + Interval::new(43884, 43887), + Interval::new(44014, 44015), + Interval::new(44026, 44031), + Interval::new(55204, 55215), + Interval::new(55239, 55242), + Interval::new(55292, 63743), + Interval::new(64110, 64111), + Interval::new(64218, 64255), + Interval::new(64263, 64274), + Interval::new(64280, 64284), + Interval::new(64311, 64311), + Interval::new(64317, 64317), + Interval::new(64319, 64319), + Interval::new(64322, 64322), + Interval::new(64325, 64325), + Interval::new(64976, 65007), + Interval::new(65050, 65055), + Interval::new(65107, 65107), + Interval::new(65127, 65127), + Interval::new(65132, 65135), + Interval::new(65141, 65141), + Interval::new(65277, 65280), + Interval::new(65471, 65473), + Interval::new(65480, 65481), + Interval::new(65488, 65489), + Interval::new(65496, 65497), + Interval::new(65501, 65503), + Interval::new(65511, 65511), + Interval::new(65519, 65531), + Interval::new(65534, 65535), + Interval::new(65548, 65548), + Interval::new(65575, 65575), + Interval::new(65595, 65595), + Interval::new(65598, 65598), + Interval::new(65614, 65615), + Interval::new(65630, 65663), + Interval::new(65787, 65791), + Interval::new(65795, 65798), + Interval::new(65844, 65846), + Interval::new(65935, 65935), + Interval::new(65949, 65951), + Interval::new(65953, 65999), + Interval::new(66046, 66175), + Interval::new(66205, 66207), + Interval::new(66257, 66271), + Interval::new(66300, 66303), + Interval::new(66340, 66348), + Interval::new(66379, 66383), + Interval::new(66427, 66431), + Interval::new(66462, 66462), + Interval::new(66500, 66503), + Interval::new(66518, 66559), + Interval::new(66718, 66719), + Interval::new(66730, 66735), + Interval::new(66772, 66775), + Interval::new(66812, 66815), + Interval::new(66856, 66863), + Interval::new(66916, 66926), + Interval::new(66939, 66939), + Interval::new(66955, 66955), + Interval::new(66963, 66963), + Interval::new(66966, 66966), + Interval::new(66978, 66978), + Interval::new(66994, 66994), + Interval::new(67002, 67002), + Interval::new(67005, 67007), + Interval::new(67060, 67071), + Interval::new(67383, 67391), + Interval::new(67414, 67423), + Interval::new(67432, 67455), + Interval::new(67462, 67462), + Interval::new(67505, 67505), + Interval::new(67515, 67583), + Interval::new(67590, 67591), + Interval::new(67593, 67593), + Interval::new(67638, 67638), + Interval::new(67641, 67643), + Interval::new(67645, 67646), + Interval::new(67670, 67670), + Interval::new(67743, 67750), + Interval::new(67760, 67807), + Interval::new(67827, 67827), + Interval::new(67830, 67834), + Interval::new(67868, 67870), + Interval::new(67898, 67902), + Interval::new(67930, 67967), + Interval::new(68024, 68027), + Interval::new(68048, 68049), + Interval::new(68100, 68100), + Interval::new(68103, 68107), + Interval::new(68116, 68116), + Interval::new(68120, 68120), + Interval::new(68150, 68151), + Interval::new(68155, 68158), + Interval::new(68169, 68175), + Interval::new(68185, 68191), + Interval::new(68256, 68287), + Interval::new(68327, 68330), + Interval::new(68343, 68351), + Interval::new(68406, 68408), + Interval::new(68438, 68439), + Interval::new(68467, 68471), + Interval::new(68498, 68504), + Interval::new(68509, 68520), + Interval::new(68528, 68607), + Interval::new(68681, 68735), + Interval::new(68787, 68799), + Interval::new(68851, 68857), + Interval::new(68904, 68911), + Interval::new(68922, 68927), + Interval::new(68966, 68968), + Interval::new(68998, 69005), + Interval::new(69008, 69215), + Interval::new(69247, 69247), + Interval::new(69290, 69290), + Interval::new(69294, 69295), + Interval::new(69298, 69313), + Interval::new(69320, 69327), + Interval::new(69337, 69369), + Interval::new(69416, 69423), + Interval::new(69466, 69487), + Interval::new(69514, 69551), + Interval::new(69580, 69599), + Interval::new(69623, 69631), + Interval::new(69710, 69713), + Interval::new(69750, 69758), + Interval::new(69821, 69821), + Interval::new(69827, 69839), + Interval::new(69865, 69871), + Interval::new(69882, 69887), + Interval::new(69941, 69941), + Interval::new(69960, 69967), + Interval::new(70007, 70015), + Interval::new(70112, 70112), + Interval::new(70133, 70143), + Interval::new(70162, 70162), + Interval::new(70210, 70271), + Interval::new(70279, 70279), + Interval::new(70281, 70281), + Interval::new(70286, 70286), + Interval::new(70302, 70302), + Interval::new(70314, 70319), + Interval::new(70379, 70383), + Interval::new(70394, 70399), + Interval::new(70404, 70404), + Interval::new(70413, 70414), + Interval::new(70417, 70418), + Interval::new(70441, 70441), + Interval::new(70449, 70449), + Interval::new(70452, 70452), + Interval::new(70458, 70458), + Interval::new(70469, 70470), + Interval::new(70473, 70474), + Interval::new(70478, 70479), + Interval::new(70481, 70486), + Interval::new(70488, 70492), + Interval::new(70500, 70501), + Interval::new(70509, 70511), + Interval::new(70517, 70527), + Interval::new(70538, 70538), + Interval::new(70540, 70541), + Interval::new(70543, 70543), + Interval::new(70582, 70582), + Interval::new(70593, 70593), + Interval::new(70595, 70596), + Interval::new(70598, 70598), + Interval::new(70603, 70603), + Interval::new(70614, 70614), + Interval::new(70617, 70624), + Interval::new(70627, 70655), + Interval::new(70748, 70748), + Interval::new(70754, 70783), + Interval::new(70856, 70863), + Interval::new(70874, 71039), + Interval::new(71094, 71095), + Interval::new(71134, 71167), + Interval::new(71237, 71247), + Interval::new(71258, 71263), + Interval::new(71277, 71295), + Interval::new(71354, 71359), + Interval::new(71370, 71375), + Interval::new(71396, 71423), + Interval::new(71451, 71452), + Interval::new(71468, 71471), + Interval::new(71495, 71679), + Interval::new(71740, 71839), + Interval::new(71923, 71934), + Interval::new(71943, 71944), + Interval::new(71946, 71947), + Interval::new(71956, 71956), + Interval::new(71959, 71959), + Interval::new(71990, 71990), + Interval::new(71993, 71994), + Interval::new(72007, 72015), + Interval::new(72026, 72095), + Interval::new(72104, 72105), + Interval::new(72152, 72153), + Interval::new(72165, 72191), + Interval::new(72264, 72271), + Interval::new(72355, 72367), + Interval::new(72441, 72447), + Interval::new(72458, 72543), + Interval::new(72552, 72639), + Interval::new(72674, 72687), + Interval::new(72698, 72703), + Interval::new(72713, 72713), + Interval::new(72759, 72759), + Interval::new(72774, 72783), + Interval::new(72813, 72815), + Interval::new(72848, 72849), + Interval::new(72872, 72872), + Interval::new(72887, 72959), + Interval::new(72967, 72967), + Interval::new(72970, 72970), + Interval::new(73015, 73017), + Interval::new(73019, 73019), + Interval::new(73022, 73022), + Interval::new(73032, 73039), + Interval::new(73050, 73055), + Interval::new(73062, 73062), + Interval::new(73065, 73065), + Interval::new(73103, 73103), + Interval::new(73106, 73106), + Interval::new(73113, 73119), + Interval::new(73130, 73135), + Interval::new(73180, 73183), + Interval::new(73194, 73439), + Interval::new(73465, 73471), + Interval::new(73489, 73489), + Interval::new(73531, 73533), + Interval::new(73563, 73647), + Interval::new(73649, 73663), + Interval::new(73714, 73726), + Interval::new(74650, 74751), + Interval::new(74863, 74863), + Interval::new(74869, 74879), + Interval::new(75076, 77711), + Interval::new(77811, 77823), + Interval::new(78896, 78911), + Interval::new(78934, 78943), + Interval::new(82939, 82943), + Interval::new(83527, 90367), + Interval::new(90426, 92159), + Interval::new(92729, 92735), + Interval::new(92767, 92767), + Interval::new(92778, 92781), + Interval::new(92863, 92863), + Interval::new(92874, 92879), + Interval::new(92910, 92911), + Interval::new(92918, 92927), + Interval::new(92998, 93007), + Interval::new(93018, 93018), + Interval::new(93026, 93026), + Interval::new(93048, 93052), + Interval::new(93072, 93503), + Interval::new(93562, 93759), + Interval::new(93851, 93855), + Interval::new(93881, 93882), + Interval::new(93908, 93951), + Interval::new(94027, 94030), + Interval::new(94088, 94094), + Interval::new(94112, 94175), + Interval::new(94181, 94191), + Interval::new(94199, 94207), + Interval::new(101590, 101630), + Interval::new(101663, 101759), + Interval::new(101875, 110575), + Interval::new(110580, 110580), + Interval::new(110588, 110588), + Interval::new(110591, 110591), + Interval::new(110883, 110897), + Interval::new(110899, 110927), + Interval::new(110931, 110932), + Interval::new(110934, 110947), + Interval::new(110952, 110959), + Interval::new(111356, 113663), + Interval::new(113771, 113775), + Interval::new(113789, 113791), + Interval::new(113801, 113807), + Interval::new(113818, 113819), + Interval::new(113824, 117759), + Interval::new(118013, 118015), + Interval::new(118452, 118457), + Interval::new(118481, 118495), + Interval::new(118513, 118527), + Interval::new(118574, 118575), + Interval::new(118599, 118607), + Interval::new(118724, 118783), + Interval::new(119030, 119039), + Interval::new(119079, 119080), + Interval::new(119155, 119162), + Interval::new(119275, 119295), + Interval::new(119366, 119487), + Interval::new(119508, 119519), + Interval::new(119540, 119551), + Interval::new(119639, 119647), + Interval::new(119673, 119807), + Interval::new(119893, 119893), + Interval::new(119965, 119965), + Interval::new(119968, 119969), + Interval::new(119971, 119972), + Interval::new(119975, 119976), + Interval::new(119981, 119981), + Interval::new(119994, 119994), + Interval::new(119996, 119996), + Interval::new(120004, 120004), + Interval::new(120070, 120070), + Interval::new(120075, 120076), + Interval::new(120085, 120085), + Interval::new(120093, 120093), + Interval::new(120122, 120122), + Interval::new(120127, 120127), + Interval::new(120133, 120133), + Interval::new(120135, 120137), + Interval::new(120145, 120145), + Interval::new(120486, 120487), + Interval::new(120780, 120781), + Interval::new(121484, 121498), + Interval::new(121504, 121504), + Interval::new(121520, 122623), + Interval::new(122655, 122660), + Interval::new(122667, 122879), + Interval::new(122887, 122887), + Interval::new(122905, 122906), + Interval::new(122914, 122914), + Interval::new(122917, 122917), + Interval::new(122923, 122927), + Interval::new(122990, 123022), + Interval::new(123024, 123135), + Interval::new(123181, 123183), + Interval::new(123198, 123199), + Interval::new(123210, 123213), + Interval::new(123216, 123535), + Interval::new(123567, 123583), + Interval::new(123642, 123646), + Interval::new(123648, 124111), + Interval::new(124154, 124367), + Interval::new(124411, 124414), + Interval::new(124416, 124607), + Interval::new(124639, 124639), + Interval::new(124662, 124669), + Interval::new(124672, 124895), + Interval::new(124903, 124903), + Interval::new(124908, 124908), + Interval::new(124911, 124911), + Interval::new(124927, 124927), + Interval::new(125125, 125126), + Interval::new(125143, 125183), + Interval::new(125260, 125263), + Interval::new(125274, 125277), + Interval::new(125280, 126064), + Interval::new(126133, 126208), + Interval::new(126270, 126463), + Interval::new(126468, 126468), + Interval::new(126496, 126496), + Interval::new(126499, 126499), + Interval::new(126501, 126502), + Interval::new(126504, 126504), + Interval::new(126515, 126515), + Interval::new(126520, 126520), + Interval::new(126522, 126522), + Interval::new(126524, 126529), + Interval::new(126531, 126534), + Interval::new(126536, 126536), + Interval::new(126538, 126538), + Interval::new(126540, 126540), + Interval::new(126544, 126544), + Interval::new(126547, 126547), + Interval::new(126549, 126550), + Interval::new(126552, 126552), + Interval::new(126554, 126554), + Interval::new(126556, 126556), + Interval::new(126558, 126558), + Interval::new(126560, 126560), + Interval::new(126563, 126563), + Interval::new(126565, 126566), + Interval::new(126571, 126571), + Interval::new(126579, 126579), + Interval::new(126584, 126584), + Interval::new(126589, 126589), + Interval::new(126591, 126591), + Interval::new(126602, 126602), + Interval::new(126620, 126624), + Interval::new(126628, 126628), + Interval::new(126634, 126634), + Interval::new(126652, 126703), + Interval::new(126706, 126975), + Interval::new(127020, 127023), + Interval::new(127124, 127135), + Interval::new(127151, 127152), + Interval::new(127168, 127168), + Interval::new(127184, 127184), + Interval::new(127222, 127231), + Interval::new(127406, 127461), + Interval::new(127491, 127503), + Interval::new(127548, 127551), + Interval::new(127561, 127567), + Interval::new(127570, 127583), + Interval::new(127590, 127743), + Interval::new(128729, 128731), + Interval::new(128749, 128751), + Interval::new(128765, 128767), + Interval::new(128986, 128991), + Interval::new(129004, 129007), + Interval::new(129009, 129023), + Interval::new(129036, 129039), + Interval::new(129096, 129103), + Interval::new(129114, 129119), + Interval::new(129160, 129167), + Interval::new(129198, 129199), + Interval::new(129212, 129215), + Interval::new(129218, 129231), + Interval::new(129241, 129279), + Interval::new(129624, 129631), + Interval::new(129646, 129647), + Interval::new(129661, 129663), + Interval::new(129675, 129677), + Interval::new(129735, 129735), + Interval::new(129737, 129740), + Interval::new(129757, 129758), + Interval::new(129771, 129774), + Interval::new(129785, 129791), + Interval::new(129939, 129939), + Interval::new(130043, 131071), + Interval::new(173792, 173823), + Interval::new(178206, 178207), + Interval::new(183982, 183983), + Interval::new(191457, 191471), + Interval::new(192094, 194559), + Interval::new(195102, 196607), + Interval::new(201547, 201551), + Interval::new(210042, 917759), + Interval::new(918000, 1114111), +]; + +/// Return the code point ranges of the 'Other' Unicode property. +pub(crate) fn other_ranges() -> &'static [Interval] { + &OTHER +} + +const LETTER: [Interval; 684] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(181, 181), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 705), + Interval::new(710, 721), + Interval::new(736, 740), + Interval::new(748, 748), + Interval::new(750, 750), + Interval::new(880, 884), + Interval::new(886, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 1013), + Interval::new(1015, 1153), + Interval::new(1162, 1327), + Interval::new(1329, 1366), + Interval::new(1369, 1369), + Interval::new(1376, 1416), + Interval::new(1488, 1514), + Interval::new(1519, 1522), + Interval::new(1568, 1610), + Interval::new(1646, 1647), + Interval::new(1649, 1747), + Interval::new(1749, 1749), + Interval::new(1765, 1766), + Interval::new(1774, 1775), + Interval::new(1786, 1788), + Interval::new(1791, 1791), + Interval::new(1808, 1808), + Interval::new(1810, 1839), + Interval::new(1869, 1957), + Interval::new(1969, 1969), + Interval::new(1994, 2026), + Interval::new(2036, 2037), + Interval::new(2042, 2042), + Interval::new(2048, 2069), + Interval::new(2074, 2074), + Interval::new(2084, 2084), + Interval::new(2088, 2088), + Interval::new(2112, 2136), + Interval::new(2144, 2154), + Interval::new(2160, 2183), + Interval::new(2185, 2191), + Interval::new(2208, 2249), + Interval::new(2308, 2361), + Interval::new(2365, 2365), + Interval::new(2384, 2384), + Interval::new(2392, 2401), + Interval::new(2417, 2432), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2493, 2493), + Interval::new(2510, 2510), + Interval::new(2524, 2525), + Interval::new(2527, 2529), + Interval::new(2544, 2545), + Interval::new(2556, 2556), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2674, 2676), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2749, 2749), + Interval::new(2768, 2768), + Interval::new(2784, 2785), + Interval::new(2809, 2809), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2877, 2877), + Interval::new(2908, 2909), + Interval::new(2911, 2913), + Interval::new(2929, 2929), + Interval::new(2947, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3024, 3024), + Interval::new(3077, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3133, 3133), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3169), + Interval::new(3200, 3200), + Interval::new(3205, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3261, 3261), + Interval::new(3292, 3294), + Interval::new(3296, 3297), + Interval::new(3313, 3314), + Interval::new(3332, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3386), + Interval::new(3389, 3389), + Interval::new(3406, 3406), + Interval::new(3412, 3414), + Interval::new(3423, 3425), + Interval::new(3450, 3455), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3585, 3632), + Interval::new(3634, 3635), + Interval::new(3648, 3654), + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3760), + Interval::new(3762, 3763), + Interval::new(3773, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3804, 3807), + Interval::new(3840, 3840), + Interval::new(3904, 3911), + Interval::new(3913, 3948), + Interval::new(3976, 3980), + Interval::new(4096, 4138), + Interval::new(4159, 4159), + Interval::new(4176, 4181), + Interval::new(4186, 4189), + Interval::new(4193, 4193), + Interval::new(4197, 4198), + Interval::new(4206, 4208), + Interval::new(4213, 4225), + Interval::new(4238, 4238), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4992, 5007), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(5121, 5740), + Interval::new(5743, 5759), + Interval::new(5761, 5786), + Interval::new(5792, 5866), + Interval::new(5873, 5880), + Interval::new(5888, 5905), + Interval::new(5919, 5937), + Interval::new(5952, 5969), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6016, 6067), + Interval::new(6103, 6103), + Interval::new(6108, 6108), + Interval::new(6176, 6264), + Interval::new(6272, 6276), + Interval::new(6279, 6312), + Interval::new(6314, 6314), + Interval::new(6320, 6389), + Interval::new(6400, 6430), + Interval::new(6480, 6509), + Interval::new(6512, 6516), + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6656, 6678), + Interval::new(6688, 6740), + Interval::new(6823, 6823), + Interval::new(6917, 6963), + Interval::new(6981, 6988), + Interval::new(7043, 7072), + Interval::new(7086, 7087), + Interval::new(7098, 7141), + Interval::new(7168, 7203), + Interval::new(7245, 7247), + Interval::new(7258, 7293), + Interval::new(7296, 7306), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7414), + Interval::new(7418, 7418), + Interval::new(7424, 7615), + Interval::new(7680, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8124), + Interval::new(8126, 8126), + Interval::new(8130, 8132), + Interval::new(8134, 8140), + Interval::new(8144, 8147), + Interval::new(8150, 8155), + Interval::new(8160, 8172), + Interval::new(8178, 8180), + Interval::new(8182, 8188), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8450, 8450), + Interval::new(8455, 8455), + Interval::new(8458, 8467), + Interval::new(8469, 8469), + Interval::new(8473, 8477), + Interval::new(8484, 8484), + Interval::new(8486, 8486), + Interval::new(8488, 8488), + Interval::new(8490, 8493), + Interval::new(8495, 8505), + Interval::new(8508, 8511), + Interval::new(8517, 8521), + Interval::new(8526, 8526), + Interval::new(8579, 8580), + Interval::new(11264, 11492), + Interval::new(11499, 11502), + Interval::new(11506, 11507), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11568, 11623), + Interval::new(11631, 11631), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(11823, 11823), + Interval::new(12293, 12294), + Interval::new(12337, 12341), + Interval::new(12347, 12348), + Interval::new(12353, 12438), + Interval::new(12445, 12447), + Interval::new(12449, 12538), + Interval::new(12540, 12543), + Interval::new(12549, 12591), + Interval::new(12593, 12686), + Interval::new(12704, 12735), + Interval::new(12784, 12799), + Interval::new(13312, 19903), + Interval::new(19968, 42124), + Interval::new(42192, 42237), + Interval::new(42240, 42508), + Interval::new(42512, 42527), + Interval::new(42538, 42539), + Interval::new(42560, 42606), + Interval::new(42623, 42653), + Interval::new(42656, 42725), + Interval::new(42775, 42783), + Interval::new(42786, 42888), + Interval::new(42891, 42972), + Interval::new(42993, 43009), + Interval::new(43011, 43013), + Interval::new(43015, 43018), + Interval::new(43020, 43042), + Interval::new(43072, 43123), + Interval::new(43138, 43187), + Interval::new(43250, 43255), + Interval::new(43259, 43259), + Interval::new(43261, 43262), + Interval::new(43274, 43301), + Interval::new(43312, 43334), + Interval::new(43360, 43388), + Interval::new(43396, 43442), + Interval::new(43471, 43471), + Interval::new(43488, 43492), + Interval::new(43494, 43503), + Interval::new(43514, 43518), + Interval::new(43520, 43560), + Interval::new(43584, 43586), + Interval::new(43588, 43595), + Interval::new(43616, 43638), + Interval::new(43642, 43642), + Interval::new(43646, 43695), + Interval::new(43697, 43697), + Interval::new(43701, 43702), + Interval::new(43705, 43709), + Interval::new(43712, 43712), + Interval::new(43714, 43714), + Interval::new(43739, 43741), + Interval::new(43744, 43754), + Interval::new(43762, 43764), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(43824, 43866), + Interval::new(43868, 43881), + Interval::new(43888, 44002), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(64256, 64262), + Interval::new(64275, 64279), + Interval::new(64285, 64285), + Interval::new(64287, 64296), + Interval::new(64298, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64433), + Interval::new(64467, 64829), + Interval::new(64848, 64911), + Interval::new(64914, 64967), + Interval::new(65008, 65019), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(65382, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(66176, 66204), + Interval::new(66208, 66256), + Interval::new(66304, 66335), + Interval::new(66349, 66368), + Interval::new(66370, 66377), + Interval::new(66384, 66421), + Interval::new(66432, 66461), + Interval::new(66464, 66499), + Interval::new(66504, 66511), + Interval::new(66560, 66717), + Interval::new(66736, 66771), + Interval::new(66776, 66811), + Interval::new(66816, 66855), + Interval::new(66864, 66915), + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), + Interval::new(67008, 67059), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67669), + Interval::new(67680, 67702), + Interval::new(67712, 67742), + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67840, 67861), + Interval::new(67872, 67897), + Interval::new(67904, 67929), + Interval::new(67968, 68023), + Interval::new(68030, 68031), + Interval::new(68096, 68096), + Interval::new(68112, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68192, 68220), + Interval::new(68224, 68252), + Interval::new(68288, 68295), + Interval::new(68297, 68324), + Interval::new(68352, 68405), + Interval::new(68416, 68437), + Interval::new(68448, 68466), + Interval::new(68480, 68497), + Interval::new(68608, 68680), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68864, 68899), + Interval::new(68938, 68965), + Interval::new(68975, 68997), + Interval::new(69248, 69289), + Interval::new(69296, 69297), + Interval::new(69314, 69319), + Interval::new(69376, 69404), + Interval::new(69415, 69415), + Interval::new(69424, 69445), + Interval::new(69488, 69505), + Interval::new(69552, 69572), + Interval::new(69600, 69622), + Interval::new(69635, 69687), + Interval::new(69745, 69746), + Interval::new(69749, 69749), + Interval::new(69763, 69807), + Interval::new(69840, 69864), + Interval::new(69891, 69926), + Interval::new(69956, 69956), + Interval::new(69959, 69959), + Interval::new(69968, 70002), + Interval::new(70006, 70006), + Interval::new(70019, 70066), + Interval::new(70081, 70084), + Interval::new(70106, 70106), + Interval::new(70108, 70108), + Interval::new(70144, 70161), + Interval::new(70163, 70187), + Interval::new(70207, 70208), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70312), + Interval::new(70320, 70366), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70461, 70461), + Interval::new(70480, 70480), + Interval::new(70493, 70497), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70583), + Interval::new(70609, 70609), + Interval::new(70611, 70611), + Interval::new(70656, 70708), + Interval::new(70727, 70730), + Interval::new(70751, 70753), + Interval::new(70784, 70831), + Interval::new(70852, 70853), + Interval::new(70855, 70855), + Interval::new(71040, 71086), + Interval::new(71128, 71131), + Interval::new(71168, 71215), + Interval::new(71236, 71236), + Interval::new(71296, 71338), + Interval::new(71352, 71352), + Interval::new(71424, 71450), + Interval::new(71488, 71494), + Interval::new(71680, 71723), + Interval::new(71840, 71903), + Interval::new(71935, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71983), + Interval::new(71999, 71999), + Interval::new(72001, 72001), + Interval::new(72096, 72103), + Interval::new(72106, 72144), + Interval::new(72161, 72161), + Interval::new(72163, 72163), + Interval::new(72192, 72192), + Interval::new(72203, 72242), + Interval::new(72250, 72250), + Interval::new(72272, 72272), + Interval::new(72284, 72329), + Interval::new(72349, 72349), + Interval::new(72368, 72440), + Interval::new(72640, 72672), + Interval::new(72704, 72712), + Interval::new(72714, 72750), + Interval::new(72768, 72768), + Interval::new(72818, 72847), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73008), + Interval::new(73030, 73030), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73097), + Interval::new(73112, 73112), + Interval::new(73136, 73179), + Interval::new(73440, 73458), + Interval::new(73474, 73474), + Interval::new(73476, 73488), + Interval::new(73490, 73523), + Interval::new(73648, 73648), + Interval::new(73728, 74649), + Interval::new(74880, 75075), + Interval::new(77712, 77808), + Interval::new(77824, 78895), + Interval::new(78913, 78918), + Interval::new(78944, 82938), + Interval::new(82944, 83526), + Interval::new(90368, 90397), + Interval::new(92160, 92728), + Interval::new(92736, 92766), + Interval::new(92784, 92862), + Interval::new(92880, 92909), + Interval::new(92928, 92975), + Interval::new(92992, 92995), + Interval::new(93027, 93047), + Interval::new(93053, 93071), + Interval::new(93504, 93548), + Interval::new(93760, 93823), + Interval::new(93856, 93880), + Interval::new(93883, 93907), + Interval::new(93952, 94026), + Interval::new(94032, 94032), + Interval::new(94099, 94111), + Interval::new(94176, 94177), + Interval::new(94179, 94179), + Interval::new(94194, 94195), + Interval::new(94208, 101589), + Interval::new(101631, 101662), + Interval::new(101760, 101874), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110882), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(110933, 110933), + Interval::new(110948, 110951), + Interval::new(110960, 111355), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120512), + Interval::new(120514, 120538), + Interval::new(120540, 120570), + Interval::new(120572, 120596), + Interval::new(120598, 120628), + Interval::new(120630, 120654), + Interval::new(120656, 120686), + Interval::new(120688, 120712), + Interval::new(120714, 120744), + Interval::new(120746, 120770), + Interval::new(120772, 120779), + Interval::new(122624, 122654), + Interval::new(122661, 122666), + Interval::new(122928, 122989), + Interval::new(123136, 123180), + Interval::new(123191, 123197), + Interval::new(123214, 123214), + Interval::new(123536, 123565), + Interval::new(123584, 123627), + Interval::new(124112, 124139), + Interval::new(124368, 124397), + Interval::new(124400, 124400), + Interval::new(124608, 124638), + Interval::new(124640, 124642), + Interval::new(124644, 124645), + Interval::new(124647, 124653), + Interval::new(124656, 124660), + Interval::new(124670, 124671), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), + Interval::new(124928, 125124), + Interval::new(125184, 125251), + Interval::new(125259, 125259), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +/// Return the code point ranges of the 'Letter' Unicode property. +pub(crate) fn letter_ranges() -> &'static [Interval] { + &LETTER +} + +const MARK: [Interval; 327] = [ + Interval::new(768, 879), + Interval::new(1155, 1161), + Interval::new(1425, 1469), + Interval::new(1471, 1471), + Interval::new(1473, 1474), + Interval::new(1476, 1477), + Interval::new(1479, 1479), + Interval::new(1552, 1562), + Interval::new(1611, 1631), + Interval::new(1648, 1648), + Interval::new(1750, 1756), + Interval::new(1759, 1764), + Interval::new(1767, 1768), + Interval::new(1770, 1773), + Interval::new(1809, 1809), + Interval::new(1840, 1866), + Interval::new(1958, 1968), + Interval::new(2027, 2035), + Interval::new(2045, 2045), + Interval::new(2070, 2073), + Interval::new(2075, 2083), + Interval::new(2085, 2087), + Interval::new(2089, 2093), + Interval::new(2137, 2139), + Interval::new(2199, 2207), + Interval::new(2250, 2273), + Interval::new(2275, 2307), + Interval::new(2362, 2364), + Interval::new(2366, 2383), + Interval::new(2385, 2391), + Interval::new(2402, 2403), + Interval::new(2433, 2435), + Interval::new(2492, 2492), + Interval::new(2494, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2509), + Interval::new(2519, 2519), + Interval::new(2530, 2531), + Interval::new(2558, 2558), + Interval::new(2561, 2563), + Interval::new(2620, 2620), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2672, 2673), + Interval::new(2677, 2677), + Interval::new(2689, 2691), + Interval::new(2748, 2748), + Interval::new(2750, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2765), + Interval::new(2786, 2787), + Interval::new(2810, 2815), + Interval::new(2817, 2819), + Interval::new(2876, 2876), + Interval::new(2878, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2893), + Interval::new(2901, 2903), + Interval::new(2914, 2915), + Interval::new(2946, 2946), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3021), + Interval::new(3031, 3031), + Interval::new(3072, 3076), + Interval::new(3132, 3132), + Interval::new(3134, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3170, 3171), + Interval::new(3201, 3203), + Interval::new(3260, 3260), + Interval::new(3262, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3298, 3299), + Interval::new(3315, 3315), + Interval::new(3328, 3331), + Interval::new(3387, 3388), + Interval::new(3390, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3405), + Interval::new(3415, 3415), + Interval::new(3426, 3427), + Interval::new(3457, 3459), + Interval::new(3530, 3530), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3570, 3571), + Interval::new(3633, 3633), + Interval::new(3636, 3642), + Interval::new(3655, 3662), + Interval::new(3761, 3761), + Interval::new(3764, 3772), + Interval::new(3784, 3790), + Interval::new(3864, 3865), + Interval::new(3893, 3893), + Interval::new(3895, 3895), + Interval::new(3897, 3897), + Interval::new(3902, 3903), + Interval::new(3953, 3972), + Interval::new(3974, 3975), + Interval::new(3981, 3991), + Interval::new(3993, 4028), + Interval::new(4038, 4038), + Interval::new(4139, 4158), + Interval::new(4182, 4185), + Interval::new(4190, 4192), + Interval::new(4194, 4196), + Interval::new(4199, 4205), + Interval::new(4209, 4212), + Interval::new(4226, 4237), + Interval::new(4239, 4239), + Interval::new(4250, 4253), + Interval::new(4957, 4959), + Interval::new(5906, 5909), + Interval::new(5938, 5940), + Interval::new(5970, 5971), + Interval::new(6002, 6003), + Interval::new(6068, 6099), + Interval::new(6109, 6109), + Interval::new(6155, 6157), + Interval::new(6159, 6159), + Interval::new(6277, 6278), + Interval::new(6313, 6313), + Interval::new(6432, 6443), + Interval::new(6448, 6459), + Interval::new(6679, 6683), + Interval::new(6741, 6750), + Interval::new(6752, 6780), + Interval::new(6783, 6783), + Interval::new(6832, 6877), + Interval::new(6880, 6891), + Interval::new(6912, 6916), + Interval::new(6964, 6980), + Interval::new(7019, 7027), + Interval::new(7040, 7042), + Interval::new(7073, 7085), + Interval::new(7142, 7155), + Interval::new(7204, 7223), + Interval::new(7376, 7378), + Interval::new(7380, 7400), + Interval::new(7405, 7405), + Interval::new(7412, 7412), + Interval::new(7415, 7417), + Interval::new(7616, 7679), + Interval::new(8400, 8432), + Interval::new(11503, 11505), + Interval::new(11647, 11647), + Interval::new(11744, 11775), + Interval::new(12330, 12335), + Interval::new(12441, 12442), + Interval::new(42607, 42610), + Interval::new(42612, 42621), + Interval::new(42654, 42655), + Interval::new(42736, 42737), + Interval::new(43010, 43010), + Interval::new(43014, 43014), + Interval::new(43019, 43019), + Interval::new(43043, 43047), + Interval::new(43052, 43052), + Interval::new(43136, 43137), + Interval::new(43188, 43205), + Interval::new(43232, 43249), + Interval::new(43263, 43263), + Interval::new(43302, 43309), + Interval::new(43335, 43347), + Interval::new(43392, 43395), + Interval::new(43443, 43456), + Interval::new(43493, 43493), + Interval::new(43561, 43574), + Interval::new(43587, 43587), + Interval::new(43596, 43597), + Interval::new(43643, 43645), + Interval::new(43696, 43696), + Interval::new(43698, 43700), + Interval::new(43703, 43704), + Interval::new(43710, 43711), + Interval::new(43713, 43713), + Interval::new(43755, 43759), + Interval::new(43765, 43766), + Interval::new(44003, 44010), + Interval::new(44012, 44013), + Interval::new(64286, 64286), + Interval::new(65024, 65039), + Interval::new(65056, 65071), + Interval::new(66045, 66045), + Interval::new(66272, 66272), + Interval::new(66422, 66426), + Interval::new(68097, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68111), + Interval::new(68152, 68154), + Interval::new(68159, 68159), + Interval::new(68325, 68326), + Interval::new(68900, 68903), + Interval::new(68969, 68973), + Interval::new(69291, 69292), + Interval::new(69370, 69375), + Interval::new(69446, 69456), + Interval::new(69506, 69509), + Interval::new(69632, 69634), + Interval::new(69688, 69702), + Interval::new(69744, 69744), + Interval::new(69747, 69748), + Interval::new(69759, 69762), + Interval::new(69808, 69818), + Interval::new(69826, 69826), + Interval::new(69888, 69890), + Interval::new(69927, 69940), + Interval::new(69957, 69958), + Interval::new(70003, 70003), + Interval::new(70016, 70018), + Interval::new(70067, 70080), + Interval::new(70089, 70092), + Interval::new(70094, 70095), + Interval::new(70188, 70199), + Interval::new(70206, 70206), + Interval::new(70209, 70209), + Interval::new(70367, 70378), + Interval::new(70400, 70403), + Interval::new(70459, 70460), + Interval::new(70462, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70487, 70487), + Interval::new(70498, 70499), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(70584, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70608), + Interval::new(70610, 70610), + Interval::new(70625, 70626), + Interval::new(70709, 70726), + Interval::new(70750, 70750), + Interval::new(70832, 70851), + Interval::new(71087, 71093), + Interval::new(71096, 71104), + Interval::new(71132, 71133), + Interval::new(71216, 71232), + Interval::new(71339, 71351), + Interval::new(71453, 71467), + Interval::new(71724, 71738), + Interval::new(71984, 71989), + Interval::new(71991, 71992), + Interval::new(71995, 71998), + Interval::new(72000, 72000), + Interval::new(72002, 72003), + Interval::new(72145, 72151), + Interval::new(72154, 72160), + Interval::new(72164, 72164), + Interval::new(72193, 72202), + Interval::new(72243, 72249), + Interval::new(72251, 72254), + Interval::new(72263, 72263), + Interval::new(72273, 72283), + Interval::new(72330, 72345), + Interval::new(72544, 72551), + Interval::new(72751, 72758), + Interval::new(72760, 72767), + Interval::new(72850, 72871), + Interval::new(72873, 72886), + Interval::new(73009, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73029), + Interval::new(73031, 73031), + Interval::new(73098, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73111), + Interval::new(73459, 73462), + Interval::new(73472, 73473), + Interval::new(73475, 73475), + Interval::new(73524, 73530), + Interval::new(73534, 73538), + Interval::new(73562, 73562), + Interval::new(78912, 78912), + Interval::new(78919, 78933), + Interval::new(90398, 90415), + Interval::new(92912, 92916), + Interval::new(92976, 92982), + Interval::new(94031, 94031), + Interval::new(94033, 94087), + Interval::new(94095, 94098), + Interval::new(94180, 94180), + Interval::new(94192, 94193), + Interval::new(113821, 113822), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119141, 119145), + Interval::new(119149, 119154), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(119362, 119364), + Interval::new(121344, 121398), + Interval::new(121403, 121452), + Interval::new(121461, 121461), + Interval::new(121476, 121476), + Interval::new(121499, 121503), + Interval::new(121505, 121519), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), + Interval::new(123023, 123023), + Interval::new(123184, 123190), + Interval::new(123566, 123566), + Interval::new(123628, 123631), + Interval::new(124140, 124143), + Interval::new(124398, 124399), + Interval::new(124643, 124643), + Interval::new(124646, 124646), + Interval::new(124654, 124655), + Interval::new(124661, 124661), + Interval::new(125136, 125142), + Interval::new(125252, 125258), + Interval::new(917760, 917999), +]; + +/// Return the code point ranges of the 'Mark' Unicode property. +pub(crate) fn mark_ranges() -> &'static [Interval] { + &MARK +} + +const NUMBER: [Interval; 146] = [ + Interval::new(48, 57), + Interval::new(178, 179), + Interval::new(185, 185), + Interval::new(188, 190), + Interval::new(1632, 1641), + Interval::new(1776, 1785), + Interval::new(1984, 1993), + Interval::new(2406, 2415), + Interval::new(2534, 2543), + Interval::new(2548, 2553), + Interval::new(2662, 2671), + Interval::new(2790, 2799), + Interval::new(2918, 2927), + Interval::new(2930, 2935), + Interval::new(3046, 3058), + Interval::new(3174, 3183), + Interval::new(3192, 3198), + Interval::new(3302, 3311), + Interval::new(3416, 3422), + Interval::new(3430, 3448), + Interval::new(3558, 3567), + Interval::new(3664, 3673), + Interval::new(3792, 3801), + Interval::new(3872, 3891), + Interval::new(4160, 4169), + Interval::new(4240, 4249), + Interval::new(4969, 4988), + Interval::new(5870, 5872), + Interval::new(6112, 6121), + Interval::new(6128, 6137), + Interval::new(6160, 6169), + Interval::new(6470, 6479), + Interval::new(6608, 6618), + Interval::new(6784, 6793), + Interval::new(6800, 6809), + Interval::new(6992, 7001), + Interval::new(7088, 7097), + Interval::new(7232, 7241), + Interval::new(7248, 7257), + Interval::new(8304, 8304), + Interval::new(8308, 8313), + Interval::new(8320, 8329), + Interval::new(8528, 8578), + Interval::new(8581, 8585), + Interval::new(9312, 9371), + Interval::new(9450, 9471), + Interval::new(10102, 10131), + Interval::new(11517, 11517), + Interval::new(12295, 12295), + Interval::new(12321, 12329), + Interval::new(12344, 12346), + Interval::new(12690, 12693), + Interval::new(12832, 12841), + Interval::new(12872, 12879), + Interval::new(12881, 12895), + Interval::new(12928, 12937), + Interval::new(12977, 12991), + Interval::new(42528, 42537), + Interval::new(42726, 42735), + Interval::new(43056, 43061), + Interval::new(43216, 43225), + Interval::new(43264, 43273), + Interval::new(43472, 43481), + Interval::new(43504, 43513), + Interval::new(43600, 43609), + Interval::new(44016, 44025), + Interval::new(65296, 65305), + Interval::new(65799, 65843), + Interval::new(65856, 65912), + Interval::new(65930, 65931), + Interval::new(66273, 66299), + Interval::new(66336, 66339), + Interval::new(66369, 66369), + Interval::new(66378, 66378), + Interval::new(66513, 66517), + Interval::new(66720, 66729), + Interval::new(67672, 67679), + Interval::new(67705, 67711), + Interval::new(67751, 67759), + Interval::new(67835, 67839), + Interval::new(67862, 67867), + Interval::new(68028, 68029), + Interval::new(68032, 68047), + Interval::new(68050, 68095), + Interval::new(68160, 68168), + Interval::new(68221, 68222), + Interval::new(68253, 68255), + Interval::new(68331, 68335), + Interval::new(68440, 68447), + Interval::new(68472, 68479), + Interval::new(68521, 68527), + Interval::new(68858, 68863), + Interval::new(68912, 68921), + Interval::new(68928, 68937), + Interval::new(69216, 69246), + Interval::new(69405, 69414), + Interval::new(69457, 69460), + Interval::new(69573, 69579), + Interval::new(69714, 69743), + Interval::new(69872, 69881), + Interval::new(69942, 69951), + Interval::new(70096, 70105), + Interval::new(70113, 70132), + Interval::new(70384, 70393), + Interval::new(70736, 70745), + Interval::new(70864, 70873), + Interval::new(71248, 71257), + Interval::new(71360, 71369), + Interval::new(71376, 71395), + Interval::new(71472, 71483), + Interval::new(71904, 71922), + Interval::new(72016, 72025), + Interval::new(72688, 72697), + Interval::new(72784, 72812), + Interval::new(73040, 73049), + Interval::new(73120, 73129), + Interval::new(73184, 73193), + Interval::new(73552, 73561), + Interval::new(73664, 73684), + Interval::new(74752, 74862), + Interval::new(90416, 90425), + Interval::new(92768, 92777), + Interval::new(92864, 92873), + Interval::new(93008, 93017), + Interval::new(93019, 93025), + Interval::new(93552, 93561), + Interval::new(93824, 93846), + Interval::new(94196, 94198), + Interval::new(118000, 118009), + Interval::new(119488, 119507), + Interval::new(119520, 119539), + Interval::new(119648, 119672), + Interval::new(120782, 120831), + Interval::new(123200, 123209), + Interval::new(123632, 123641), + Interval::new(124144, 124153), + Interval::new(124401, 124410), + Interval::new(125127, 125135), + Interval::new(125264, 125273), + Interval::new(126065, 126123), + Interval::new(126125, 126127), + Interval::new(126129, 126132), + Interval::new(126209, 126253), + Interval::new(126255, 126269), + Interval::new(127232, 127244), + Interval::new(130032, 130041), +]; + +/// Return the code point ranges of the 'Number' Unicode property. +pub(crate) fn number_ranges() -> &'static [Interval] { + &NUMBER +} + +const PUNCTUATION: [Interval; 199] = [ + Interval::new(33, 35), + Interval::new(37, 42), + Interval::new(44, 47), + Interval::new(58, 59), + Interval::new(63, 64), + Interval::new(91, 93), + Interval::new(95, 95), + Interval::new(123, 123), + Interval::new(125, 125), + Interval::new(161, 161), + Interval::new(167, 167), + Interval::new(171, 171), + Interval::new(182, 183), + Interval::new(187, 187), + Interval::new(191, 191), + Interval::new(894, 894), + Interval::new(903, 903), + Interval::new(1370, 1375), + Interval::new(1417, 1418), + Interval::new(1470, 1470), + Interval::new(1472, 1472), + Interval::new(1475, 1475), + Interval::new(1478, 1478), + Interval::new(1523, 1524), + Interval::new(1545, 1546), + Interval::new(1548, 1549), + Interval::new(1563, 1563), + Interval::new(1565, 1567), + Interval::new(1642, 1645), + Interval::new(1748, 1748), + Interval::new(1792, 1805), + Interval::new(2039, 2041), + Interval::new(2096, 2110), + Interval::new(2142, 2142), + Interval::new(2404, 2405), + Interval::new(2416, 2416), + Interval::new(2557, 2557), + Interval::new(2678, 2678), + Interval::new(2800, 2800), + Interval::new(3191, 3191), + Interval::new(3204, 3204), + Interval::new(3572, 3572), + Interval::new(3663, 3663), + Interval::new(3674, 3675), + Interval::new(3844, 3858), + Interval::new(3860, 3860), + Interval::new(3898, 3901), + Interval::new(3973, 3973), + Interval::new(4048, 4052), + Interval::new(4057, 4058), + Interval::new(4170, 4175), + Interval::new(4347, 4347), + Interval::new(4960, 4968), + Interval::new(5120, 5120), + Interval::new(5742, 5742), + Interval::new(5787, 5788), + Interval::new(5867, 5869), + Interval::new(5941, 5942), + Interval::new(6100, 6102), + Interval::new(6104, 6106), + Interval::new(6144, 6154), + Interval::new(6468, 6469), + Interval::new(6686, 6687), + Interval::new(6816, 6822), + Interval::new(6824, 6829), + Interval::new(6990, 6991), + Interval::new(7002, 7008), + Interval::new(7037, 7039), + Interval::new(7164, 7167), + Interval::new(7227, 7231), + Interval::new(7294, 7295), + Interval::new(7360, 7367), + Interval::new(7379, 7379), + Interval::new(8208, 8231), + Interval::new(8240, 8259), + Interval::new(8261, 8273), + Interval::new(8275, 8286), + Interval::new(8317, 8318), + Interval::new(8333, 8334), + Interval::new(8968, 8971), + Interval::new(9001, 9002), + Interval::new(10088, 10101), + Interval::new(10181, 10182), + Interval::new(10214, 10223), + Interval::new(10627, 10648), + Interval::new(10712, 10715), + Interval::new(10748, 10749), + Interval::new(11513, 11516), + Interval::new(11518, 11519), + Interval::new(11632, 11632), + Interval::new(11776, 11822), + Interval::new(11824, 11855), + Interval::new(11858, 11869), + Interval::new(12289, 12291), + Interval::new(12296, 12305), + Interval::new(12308, 12319), + Interval::new(12336, 12336), + Interval::new(12349, 12349), + Interval::new(12448, 12448), + Interval::new(12539, 12539), + Interval::new(42238, 42239), + Interval::new(42509, 42511), + Interval::new(42611, 42611), + Interval::new(42622, 42622), + Interval::new(42738, 42743), + Interval::new(43124, 43127), + Interval::new(43214, 43215), + Interval::new(43256, 43258), + Interval::new(43260, 43260), + Interval::new(43310, 43311), + Interval::new(43359, 43359), + Interval::new(43457, 43469), + Interval::new(43486, 43487), + Interval::new(43612, 43615), + Interval::new(43742, 43743), + Interval::new(43760, 43761), + Interval::new(44011, 44011), + Interval::new(64830, 64831), + Interval::new(65040, 65049), + Interval::new(65072, 65106), + Interval::new(65108, 65121), + Interval::new(65123, 65123), + Interval::new(65128, 65128), + Interval::new(65130, 65131), + Interval::new(65281, 65283), + Interval::new(65285, 65290), + Interval::new(65292, 65295), + Interval::new(65306, 65307), + Interval::new(65311, 65312), + Interval::new(65339, 65341), + Interval::new(65343, 65343), + Interval::new(65371, 65371), + Interval::new(65373, 65373), + Interval::new(65375, 65381), + Interval::new(65792, 65794), + Interval::new(66463, 66463), + Interval::new(66512, 66512), + Interval::new(66927, 66927), + Interval::new(67671, 67671), + Interval::new(67871, 67871), + Interval::new(67903, 67903), + Interval::new(68176, 68184), + Interval::new(68223, 68223), + Interval::new(68336, 68342), + Interval::new(68409, 68415), + Interval::new(68505, 68508), + Interval::new(68974, 68974), + Interval::new(69293, 69293), + Interval::new(69328, 69328), + Interval::new(69461, 69465), + Interval::new(69510, 69513), + Interval::new(69703, 69709), + Interval::new(69819, 69820), + Interval::new(69822, 69825), + Interval::new(69952, 69955), + Interval::new(70004, 70005), + Interval::new(70085, 70088), + Interval::new(70093, 70093), + Interval::new(70107, 70107), + Interval::new(70109, 70111), + Interval::new(70200, 70205), + Interval::new(70313, 70313), + Interval::new(70612, 70613), + Interval::new(70615, 70616), + Interval::new(70731, 70735), + Interval::new(70746, 70747), + Interval::new(70749, 70749), + Interval::new(70854, 70854), + Interval::new(71105, 71127), + Interval::new(71233, 71235), + Interval::new(71264, 71276), + Interval::new(71353, 71353), + Interval::new(71484, 71486), + Interval::new(71739, 71739), + Interval::new(72004, 72006), + Interval::new(72162, 72162), + Interval::new(72255, 72262), + Interval::new(72346, 72348), + Interval::new(72350, 72354), + Interval::new(72448, 72457), + Interval::new(72673, 72673), + Interval::new(72769, 72773), + Interval::new(72816, 72817), + Interval::new(73463, 73464), + Interval::new(73539, 73551), + Interval::new(73727, 73727), + Interval::new(74864, 74868), + Interval::new(77809, 77810), + Interval::new(92782, 92783), + Interval::new(92917, 92917), + Interval::new(92983, 92987), + Interval::new(92996, 92996), + Interval::new(93549, 93551), + Interval::new(93847, 93850), + Interval::new(94178, 94178), + Interval::new(113823, 113823), + Interval::new(121479, 121483), + Interval::new(124415, 124415), + Interval::new(125278, 125279), +]; + +/// Return the code point ranges of the 'Punctuation' Unicode property. +pub(crate) fn punctuation_ranges() -> &'static [Interval] { + &PUNCTUATION +} + +const SYMBOL: [Interval; 242] = [ + Interval::new(36, 36), + Interval::new(43, 43), + Interval::new(60, 62), + Interval::new(94, 94), + Interval::new(96, 96), + Interval::new(124, 124), + Interval::new(126, 126), + Interval::new(162, 166), + Interval::new(168, 169), + Interval::new(172, 172), + Interval::new(174, 177), + Interval::new(180, 180), + Interval::new(184, 184), + Interval::new(215, 215), + Interval::new(247, 247), + Interval::new(706, 709), + Interval::new(722, 735), + Interval::new(741, 747), + Interval::new(749, 749), + Interval::new(751, 767), + Interval::new(885, 885), + Interval::new(900, 901), + Interval::new(1014, 1014), + Interval::new(1154, 1154), + Interval::new(1421, 1423), + Interval::new(1542, 1544), + Interval::new(1547, 1547), + Interval::new(1550, 1551), + Interval::new(1758, 1758), + Interval::new(1769, 1769), + Interval::new(1789, 1790), + Interval::new(2038, 2038), + Interval::new(2046, 2047), + Interval::new(2184, 2184), + Interval::new(2546, 2547), + Interval::new(2554, 2555), + Interval::new(2801, 2801), + Interval::new(2928, 2928), + Interval::new(3059, 3066), + Interval::new(3199, 3199), + Interval::new(3407, 3407), + Interval::new(3449, 3449), + Interval::new(3647, 3647), + Interval::new(3841, 3843), + Interval::new(3859, 3859), + Interval::new(3861, 3863), + Interval::new(3866, 3871), + Interval::new(3892, 3892), + Interval::new(3894, 3894), + Interval::new(3896, 3896), + Interval::new(4030, 4037), + Interval::new(4039, 4044), + Interval::new(4046, 4047), + Interval::new(4053, 4056), + Interval::new(4254, 4255), + Interval::new(5008, 5017), + Interval::new(5741, 5741), + Interval::new(6107, 6107), + Interval::new(6464, 6464), + Interval::new(6622, 6655), + Interval::new(7009, 7018), + Interval::new(7028, 7036), + Interval::new(8125, 8125), + Interval::new(8127, 8129), + Interval::new(8141, 8143), + Interval::new(8157, 8159), + Interval::new(8173, 8175), + Interval::new(8189, 8190), + Interval::new(8260, 8260), + Interval::new(8274, 8274), + Interval::new(8314, 8316), + Interval::new(8330, 8332), + Interval::new(8352, 8385), + Interval::new(8448, 8449), + Interval::new(8451, 8454), + Interval::new(8456, 8457), + Interval::new(8468, 8468), + Interval::new(8470, 8472), + Interval::new(8478, 8483), + Interval::new(8485, 8485), + Interval::new(8487, 8487), + Interval::new(8489, 8489), + Interval::new(8494, 8494), + Interval::new(8506, 8507), + Interval::new(8512, 8516), + Interval::new(8522, 8525), + Interval::new(8527, 8527), + Interval::new(8586, 8587), + Interval::new(8592, 8967), + Interval::new(8972, 9000), + Interval::new(9003, 9257), + Interval::new(9280, 9290), + Interval::new(9372, 9449), + Interval::new(9472, 10087), + Interval::new(10132, 10180), + Interval::new(10183, 10213), + Interval::new(10224, 10626), + Interval::new(10649, 10711), + Interval::new(10716, 10747), + Interval::new(10750, 11123), + Interval::new(11126, 11263), + Interval::new(11493, 11498), + Interval::new(11856, 11857), + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), + Interval::new(12272, 12287), + Interval::new(12292, 12292), + Interval::new(12306, 12307), + Interval::new(12320, 12320), + Interval::new(12342, 12343), + Interval::new(12350, 12351), + Interval::new(12443, 12444), + Interval::new(12688, 12689), + Interval::new(12694, 12703), + Interval::new(12736, 12773), + Interval::new(12783, 12783), + Interval::new(12800, 12830), + Interval::new(12842, 12871), + Interval::new(12880, 12880), + Interval::new(12896, 12927), + Interval::new(12938, 12976), + Interval::new(12992, 13311), + Interval::new(19904, 19967), + Interval::new(42128, 42182), + Interval::new(42752, 42774), + Interval::new(42784, 42785), + Interval::new(42889, 42890), + Interval::new(43048, 43051), + Interval::new(43062, 43065), + Interval::new(43639, 43641), + Interval::new(43867, 43867), + Interval::new(43882, 43883), + Interval::new(64297, 64297), + Interval::new(64434, 64466), + Interval::new(64832, 64847), + Interval::new(64912, 64913), + Interval::new(64968, 64975), + Interval::new(65020, 65023), + Interval::new(65122, 65122), + Interval::new(65124, 65126), + Interval::new(65129, 65129), + Interval::new(65284, 65284), + Interval::new(65291, 65291), + Interval::new(65308, 65310), + Interval::new(65342, 65342), + Interval::new(65344, 65344), + Interval::new(65372, 65372), + Interval::new(65374, 65374), + Interval::new(65504, 65510), + Interval::new(65512, 65518), + Interval::new(65532, 65533), + Interval::new(65847, 65855), + Interval::new(65913, 65929), + Interval::new(65932, 65934), + Interval::new(65936, 65948), + Interval::new(65952, 65952), + Interval::new(66000, 66044), + Interval::new(67703, 67704), + Interval::new(68296, 68296), + Interval::new(69006, 69007), + Interval::new(69329, 69336), + Interval::new(71487, 71487), + Interval::new(73685, 73713), + Interval::new(92988, 92991), + Interval::new(92997, 92997), + Interval::new(113820, 113820), + Interval::new(117760, 117999), + Interval::new(118010, 118012), + Interval::new(118016, 118451), + Interval::new(118458, 118480), + Interval::new(118496, 118512), + Interval::new(118608, 118723), + Interval::new(118784, 119029), + Interval::new(119040, 119078), + Interval::new(119081, 119140), + Interval::new(119146, 119148), + Interval::new(119171, 119172), + Interval::new(119180, 119209), + Interval::new(119214, 119274), + Interval::new(119296, 119361), + Interval::new(119365, 119365), + Interval::new(119552, 119638), + Interval::new(120513, 120513), + Interval::new(120539, 120539), + Interval::new(120571, 120571), + Interval::new(120597, 120597), + Interval::new(120629, 120629), + Interval::new(120655, 120655), + Interval::new(120687, 120687), + Interval::new(120713, 120713), + Interval::new(120745, 120745), + Interval::new(120771, 120771), + Interval::new(120832, 121343), + Interval::new(121399, 121402), + Interval::new(121453, 121460), + Interval::new(121462, 121475), + Interval::new(121477, 121478), + Interval::new(123215, 123215), + Interval::new(123647, 123647), + Interval::new(126124, 126124), + Interval::new(126128, 126128), + Interval::new(126254, 126254), + Interval::new(126704, 126705), + Interval::new(126976, 127019), + Interval::new(127024, 127123), + Interval::new(127136, 127150), + Interval::new(127153, 127167), + Interval::new(127169, 127183), + Interval::new(127185, 127221), + Interval::new(127245, 127405), + Interval::new(127462, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127568, 127569), + Interval::new(127584, 127589), + Interval::new(127744, 128728), + Interval::new(128732, 128748), + Interval::new(128752, 128764), + Interval::new(128768, 128985), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129024, 129035), + Interval::new(129040, 129095), + Interval::new(129104, 129113), + Interval::new(129120, 129159), + Interval::new(129168, 129197), + Interval::new(129200, 129211), + Interval::new(129216, 129217), + Interval::new(129232, 129240), + Interval::new(129280, 129623), + Interval::new(129632, 129645), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), + Interval::new(129792, 129938), + Interval::new(129940, 130031), + Interval::new(130042, 130042), +]; + +/// Return the code point ranges of the 'Symbol' Unicode property. +pub(crate) fn symbol_ranges() -> &'static [Interval] { + &SYMBOL +} + +const SEPARATOR: [Interval; 8] = [ + Interval::new(32, 32), + Interval::new(160, 160), + Interval::new(5760, 5760), + Interval::new(8192, 8202), + Interval::new(8232, 8233), + Interval::new(8239, 8239), + Interval::new(8287, 8287), + Interval::new(12288, 12288), +]; + +/// Return the code point ranges of the 'Separator' Unicode property. +pub(crate) fn separator_ranges() -> &'static [Interval] { + &SEPARATOR +} + +pub(crate) fn general_category_property_value_ranges( + value: &UnicodePropertyValueGeneralCategory, +) -> &'static [Interval] { + use UnicodePropertyValueGeneralCategory::*; + match value { + ClosePunctuation => close_punctuation_ranges(), + ConnectorPunctuation => connector_punctuation_ranges(), + Control => control_ranges(), + CurrencySymbol => currency_symbol_ranges(), + DashPunctuation => dash_punctuation_ranges(), + DecimalNumber => decimal_number_ranges(), + EnclosingMark => enclosing_mark_ranges(), + FinalPunctuation => final_punctuation_ranges(), + Format => format_ranges(), + InitialPunctuation => initial_punctuation_ranges(), + LetterNumber => letter_number_ranges(), + LineSeparator => line_separator_ranges(), + LowercaseLetter => lowercase_letter_ranges(), + MathSymbol => math_symbol_ranges(), + ModifierLetter => modifier_letter_ranges(), + ModifierSymbol => modifier_symbol_ranges(), + NonspacingMark => nonspacing_mark_ranges(), + OpenPunctuation => open_punctuation_ranges(), + OtherLetter => other_letter_ranges(), + OtherNumber => other_number_ranges(), + OtherPunctuation => other_punctuation_ranges(), + OtherSymbol => other_symbol_ranges(), + ParagraphSeparator => paragraph_separator_ranges(), + PrivateUse => private_use_ranges(), + SpaceSeparator => space_separator_ranges(), + SpacingMark => spacing_mark_ranges(), + Surrogate => surrogate_ranges(), + TitlecaseLetter => titlecase_letter_ranges(), + Unassigned => unassigned_ranges(), + UppercaseLetter => uppercase_letter_ranges(), + CasedLetter => cased_letter_ranges(), + Other => other_ranges(), + Letter => letter_ranges(), + Mark => mark_ranges(), + Number => number_ranges(), + Punctuation => punctuation_ranges(), + Symbol => symbol_ranges(), + Separator => separator_ranges(), + } +} + +#[derive(Debug, Clone, Copy)] +pub enum UnicodePropertyValueGeneralCategory { + ClosePunctuation, + ConnectorPunctuation, + Control, + CurrencySymbol, + DashPunctuation, + DecimalNumber, + EnclosingMark, + FinalPunctuation, + Format, + InitialPunctuation, + LetterNumber, + LineSeparator, + LowercaseLetter, + MathSymbol, + ModifierLetter, + ModifierSymbol, + NonspacingMark, + OpenPunctuation, + OtherLetter, + OtherNumber, + OtherPunctuation, + OtherSymbol, + ParagraphSeparator, + PrivateUse, + SpaceSeparator, + SpacingMark, + Surrogate, + TitlecaseLetter, + Unassigned, + UppercaseLetter, + CasedLetter, + Other, + Letter, + Mark, + Number, + Punctuation, + Symbol, + Separator, +} + +pub fn unicode_property_value_general_category_from_str( + s: &str, +) -> Option { + use UnicodePropertyValueGeneralCategory::*; + match s { + "Pe" | "Close_Punctuation" => Some(ClosePunctuation), + "Pc" | "Connector_Punctuation" => Some(ConnectorPunctuation), + "cntrl" | "Cc" | "Control" => Some(Control), + "Sc" | "Currency_Symbol" => Some(CurrencySymbol), + "Pd" | "Dash_Punctuation" => Some(DashPunctuation), + "digit" | "Nd" | "Decimal_Number" => Some(DecimalNumber), + "Me" | "Enclosing_Mark" => Some(EnclosingMark), + "Pf" | "Final_Punctuation" => Some(FinalPunctuation), + "Cf" | "Format" => Some(Format), + "Pi" | "Initial_Punctuation" => Some(InitialPunctuation), + "Nl" | "Letter_Number" => Some(LetterNumber), + "Zl" | "Line_Separator" => Some(LineSeparator), + "Ll" | "Lowercase_Letter" => Some(LowercaseLetter), + "Sm" | "Math_Symbol" => Some(MathSymbol), + "Lm" | "Modifier_Letter" => Some(ModifierLetter), + "Sk" | "Modifier_Symbol" => Some(ModifierSymbol), + "Mn" | "Nonspacing_Mark" => Some(NonspacingMark), + "Ps" | "Open_Punctuation" => Some(OpenPunctuation), + "Lo" | "Other_Letter" => Some(OtherLetter), + "No" | "Other_Number" => Some(OtherNumber), + "Po" | "Other_Punctuation" => Some(OtherPunctuation), + "So" | "Other_Symbol" => Some(OtherSymbol), + "Zp" | "Paragraph_Separator" => Some(ParagraphSeparator), + "Co" | "Private_Use" => Some(PrivateUse), + "Zs" | "Space_Separator" => Some(SpaceSeparator), + "Mc" | "Spacing_Mark" => Some(SpacingMark), + "Cs" | "Surrogate" => Some(Surrogate), + "Lt" | "Titlecase_Letter" => Some(TitlecaseLetter), + "Cn" | "Unassigned" => Some(Unassigned), + "Lu" | "Uppercase_Letter" => Some(UppercaseLetter), + "LC" | "Cased_Letter" => Some(CasedLetter), + "C" | "Other" => Some(Other), + "L" | "Letter" => Some(Letter), + "Combining_Mark" | "M" | "Mark" => Some(Mark), + "N" | "Number" => Some(Number), + "punct" | "P" | "Punctuation" => Some(Punctuation), + "S" | "Symbol" => Some(Symbol), + "Z" | "Separator" => Some(Separator), + _ => None, + } +} + +const ADLAM: [Interval; 3] = [ + Interval::new(125184, 125259), + Interval::new(125264, 125273), + Interval::new(125278, 125279), +]; + +const ADLAM_EXTENSIONS: [Interval; 7] = [ + Interval::new(1567, 1567), + Interval::new(1600, 1600), + Interval::new(8271, 8271), + Interval::new(11841, 11841), + Interval::new(125184, 125259), + Interval::new(125264, 125273), + Interval::new(125278, 125279), +]; + +const CAUCASIAN_ALBANIAN: [Interval; 2] = + [Interval::new(66864, 66915), Interval::new(66927, 66927)]; + +const CAUCASIAN_ALBANIAN_EXTENSIONS: [Interval; 5] = [ + Interval::new(772, 772), + Interval::new(817, 817), + Interval::new(862, 862), + Interval::new(66864, 66915), + Interval::new(66927, 66927), +]; + +const AHOM: [Interval; 3] = [ + Interval::new(71424, 71450), + Interval::new(71453, 71467), + Interval::new(71472, 71494), +]; + +const ARABIC: [Interval; 56] = [ + Interval::new(1536, 1540), + Interval::new(1542, 1547), + Interval::new(1549, 1562), + Interval::new(1564, 1566), + Interval::new(1568, 1599), + Interval::new(1601, 1610), + Interval::new(1622, 1647), + Interval::new(1649, 1756), + Interval::new(1758, 1791), + Interval::new(1872, 1919), + Interval::new(2160, 2193), + Interval::new(2199, 2273), + Interval::new(2275, 2303), + Interval::new(64336, 64829), + Interval::new(64832, 64975), + Interval::new(65008, 65023), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(69216, 69246), + Interval::new(69314, 69319), + Interval::new(69328, 69336), + Interval::new(69370, 69375), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(126704, 126705), +]; + +const ARABIC_EXTENSIONS: [Interval; 52] = [ + Interval::new(1536, 1540), + Interval::new(1542, 1756), + Interval::new(1758, 1791), + Interval::new(1872, 1919), + Interval::new(2160, 2193), + Interval::new(2199, 2273), + Interval::new(2275, 2303), + Interval::new(8271, 8271), + Interval::new(11841, 11841), + Interval::new(64336, 64975), + Interval::new(65008, 65023), + Interval::new(65136, 65140), + Interval::new(65142, 65276), + Interval::new(66272, 66299), + Interval::new(69216, 69246), + Interval::new(69314, 69319), + Interval::new(69328, 69336), + Interval::new(69370, 69375), + Interval::new(126464, 126467), + Interval::new(126469, 126495), + Interval::new(126497, 126498), + Interval::new(126500, 126500), + Interval::new(126503, 126503), + Interval::new(126505, 126514), + Interval::new(126516, 126519), + Interval::new(126521, 126521), + Interval::new(126523, 126523), + Interval::new(126530, 126530), + Interval::new(126535, 126535), + Interval::new(126537, 126537), + Interval::new(126539, 126539), + Interval::new(126541, 126543), + Interval::new(126545, 126546), + Interval::new(126548, 126548), + Interval::new(126551, 126551), + Interval::new(126553, 126553), + Interval::new(126555, 126555), + Interval::new(126557, 126557), + Interval::new(126559, 126559), + Interval::new(126561, 126562), + Interval::new(126564, 126564), + Interval::new(126567, 126570), + Interval::new(126572, 126578), + Interval::new(126580, 126583), + Interval::new(126585, 126588), + Interval::new(126590, 126590), + Interval::new(126592, 126601), + Interval::new(126603, 126619), + Interval::new(126625, 126627), + Interval::new(126629, 126633), + Interval::new(126635, 126651), + Interval::new(126704, 126705), +]; + +const IMPERIAL_ARAMAIC: [Interval; 2] = [Interval::new(67648, 67669), Interval::new(67671, 67679)]; + +const ARMENIAN: [Interval; 4] = [ + Interval::new(1329, 1366), + Interval::new(1369, 1418), + Interval::new(1421, 1423), + Interval::new(64275, 64279), +]; + +const ARMENIAN_EXTENSIONS: [Interval; 5] = [ + Interval::new(776, 776), + Interval::new(1329, 1366), + Interval::new(1369, 1418), + Interval::new(1421, 1423), + Interval::new(64275, 64279), +]; + +const AVESTAN: [Interval; 2] = [Interval::new(68352, 68405), Interval::new(68409, 68415)]; + +const AVESTAN_EXTENSIONS: [Interval; 4] = [ + Interval::new(183, 183), + Interval::new(11824, 11825), + Interval::new(68352, 68405), + Interval::new(68409, 68415), +]; + +const BALINESE: [Interval; 2] = [Interval::new(6912, 6988), Interval::new(6990, 7039)]; + +const BAMUM: [Interval; 2] = [Interval::new(42656, 42743), Interval::new(92160, 92728)]; + +const BASSA_VAH: [Interval; 2] = [Interval::new(92880, 92909), Interval::new(92912, 92917)]; + +const BATAK: [Interval; 2] = [Interval::new(7104, 7155), Interval::new(7164, 7167)]; + +const BENGALI: [Interval; 14] = [ + Interval::new(2432, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2492, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2510), + Interval::new(2519, 2519), + Interval::new(2524, 2525), + Interval::new(2527, 2531), + Interval::new(2534, 2558), +]; + +const BENGALI_EXTENSIONS: [Interval; 27] = [ + Interval::new(700, 700), + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(2432, 2435), + Interval::new(2437, 2444), + Interval::new(2447, 2448), + Interval::new(2451, 2472), + Interval::new(2474, 2480), + Interval::new(2482, 2482), + Interval::new(2486, 2489), + Interval::new(2492, 2500), + Interval::new(2503, 2504), + Interval::new(2507, 2510), + Interval::new(2519, 2519), + Interval::new(2524, 2525), + Interval::new(2527, 2531), + Interval::new(2534, 2558), + Interval::new(7376, 7376), + Interval::new(7378, 7378), + Interval::new(7381, 7382), + Interval::new(7384, 7384), + Interval::new(7393, 7393), + Interval::new(7402, 7402), + Interval::new(7405, 7405), + Interval::new(7410, 7410), + Interval::new(7413, 7415), + Interval::new(43249, 43249), +]; + +const BERIA_ERFE: [Interval; 2] = [Interval::new(93856, 93880), Interval::new(93883, 93907)]; + +const BHAIKSUKI: [Interval; 4] = [ + Interval::new(72704, 72712), + Interval::new(72714, 72758), + Interval::new(72760, 72773), + Interval::new(72784, 72812), +]; + +const BOPOMOFO: [Interval; 3] = [ + Interval::new(746, 747), + Interval::new(12549, 12591), + Interval::new(12704, 12735), +]; + +const BOPOMOFO_EXTENSIONS: [Interval; 15] = [ + Interval::new(711, 711), + Interval::new(713, 715), + Interval::new(729, 729), + Interval::new(746, 747), + Interval::new(12289, 12291), + Interval::new(12296, 12305), + Interval::new(12307, 12319), + Interval::new(12330, 12333), + Interval::new(12336, 12336), + Interval::new(12343, 12343), + Interval::new(12539, 12539), + Interval::new(12549, 12591), + Interval::new(12704, 12735), + Interval::new(65093, 65094), + Interval::new(65377, 65381), +]; + +const BRAHMI: [Interval; 3] = [ + Interval::new(69632, 69709), + Interval::new(69714, 69749), + Interval::new(69759, 69759), +]; + +const BRAILLE: [Interval; 1] = [Interval::new(10240, 10495)]; + +const BUGINESE: [Interval; 2] = [Interval::new(6656, 6683), Interval::new(6686, 6687)]; + +const BUGINESE_EXTENSIONS: [Interval; 3] = [ + Interval::new(6656, 6683), + Interval::new(6686, 6687), + Interval::new(43471, 43471), +]; + +const BUHID: [Interval; 1] = [Interval::new(5952, 5971)]; + +const BUHID_EXTENSIONS: [Interval; 2] = [Interval::new(5941, 5942), Interval::new(5952, 5971)]; + +const CHAKMA: [Interval; 2] = [Interval::new(69888, 69940), Interval::new(69942, 69959)]; + +const CHAKMA_EXTENSIONS: [Interval; 4] = [ + Interval::new(2534, 2543), + Interval::new(4160, 4169), + Interval::new(69888, 69940), + Interval::new(69942, 69959), +]; + +const CANADIAN_ABORIGINAL: [Interval; 3] = [ + Interval::new(5120, 5759), + Interval::new(6320, 6389), + Interval::new(72368, 72383), +]; + +const CARIAN: [Interval; 1] = [Interval::new(66208, 66256)]; + +const CARIAN_EXTENSIONS: [Interval; 5] = [ + Interval::new(183, 183), + Interval::new(8282, 8282), + Interval::new(8285, 8285), + Interval::new(11825, 11825), + Interval::new(66208, 66256), +]; + +const CHAM: [Interval; 4] = [ + Interval::new(43520, 43574), + Interval::new(43584, 43597), + Interval::new(43600, 43609), + Interval::new(43612, 43615), +]; + +const CHEROKEE: [Interval; 3] = [ + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(43888, 43967), +]; + +const CHEROKEE_EXTENSIONS: [Interval; 8] = [ + Interval::new(768, 770), + Interval::new(772, 772), + Interval::new(779, 780), + Interval::new(803, 804), + Interval::new(816, 817), + Interval::new(5024, 5109), + Interval::new(5112, 5117), + Interval::new(43888, 43967), +]; + +const CHORASMIAN: [Interval; 1] = [Interval::new(69552, 69579)]; + +const COPTIC: [Interval; 3] = [ + Interval::new(994, 1007), + Interval::new(11392, 11507), + Interval::new(11513, 11519), +]; + +const COPTIC_EXTENSIONS: [Interval; 10] = [ + Interval::new(183, 183), + Interval::new(768, 768), + Interval::new(772, 773), + Interval::new(775, 775), + Interval::new(884, 885), + Interval::new(994, 1007), + Interval::new(11392, 11507), + Interval::new(11513, 11519), + Interval::new(11799, 11799), + Interval::new(66272, 66299), +]; + +const CYPRO_MINOAN: [Interval; 1] = [Interval::new(77712, 77810)]; + +const CYPRO_MINOAN_EXTENSIONS: [Interval; 2] = + [Interval::new(65792, 65793), Interval::new(77712, 77810)]; + +const CYPRIOT: [Interval; 6] = [ + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67647), +]; + +const CYPRIOT_EXTENSIONS: [Interval; 9] = [ + Interval::new(65792, 65794), + Interval::new(65799, 65843), + Interval::new(65847, 65855), + Interval::new(67584, 67589), + Interval::new(67592, 67592), + Interval::new(67594, 67637), + Interval::new(67639, 67640), + Interval::new(67644, 67644), + Interval::new(67647, 67647), +]; + +const CYRILLIC: [Interval; 10] = [ + Interval::new(1024, 1156), + Interval::new(1159, 1327), + Interval::new(7296, 7306), + Interval::new(7467, 7467), + Interval::new(7544, 7544), + Interval::new(11744, 11775), + Interval::new(42560, 42655), + Interval::new(65070, 65071), + Interval::new(122928, 122989), + Interval::new(123023, 123023), +]; + +const CYRILLIC_EXTENSIONS: [Interval; 18] = [ + Interval::new(700, 700), + Interval::new(768, 770), + Interval::new(772, 772), + Interval::new(774, 774), + Interval::new(776, 776), + Interval::new(779, 779), + Interval::new(785, 785), + Interval::new(1024, 1327), + Interval::new(7296, 7306), + Interval::new(7467, 7467), + Interval::new(7544, 7544), + Interval::new(7672, 7672), + Interval::new(11744, 11775), + Interval::new(11843, 11843), + Interval::new(42560, 42655), + Interval::new(65070, 65071), + Interval::new(122928, 122989), + Interval::new(123023, 123023), +]; + +const DEVANAGARI: [Interval; 5] = [ + Interval::new(2304, 2384), + Interval::new(2389, 2403), + Interval::new(2406, 2431), + Interval::new(43232, 43263), + Interval::new(72448, 72457), +]; + +const DEVANAGARI_EXTENSIONS: [Interval; 9] = [ + Interval::new(700, 700), + Interval::new(2304, 2386), + Interval::new(2389, 2431), + Interval::new(7376, 7414), + Interval::new(7416, 7417), + Interval::new(8432, 8432), + Interval::new(43056, 43065), + Interval::new(43232, 43263), + Interval::new(72448, 72457), +]; + +const DIVES_AKURU: [Interval; 8] = [ + Interval::new(71936, 71942), + Interval::new(71945, 71945), + Interval::new(71948, 71955), + Interval::new(71957, 71958), + Interval::new(71960, 71989), + Interval::new(71991, 71992), + Interval::new(71995, 72006), + Interval::new(72016, 72025), +]; + +const DOGRA: [Interval; 1] = [Interval::new(71680, 71739)]; + +const DOGRA_EXTENSIONS: [Interval; 3] = [ + Interval::new(2404, 2415), + Interval::new(43056, 43065), + Interval::new(71680, 71739), +]; + +const DESERET: [Interval; 1] = [Interval::new(66560, 66639)]; + +const DUPLOYAN: [Interval; 5] = [ + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113820, 113823), +]; + +const DUPLOYAN_EXTENSIONS: [Interval; 10] = [ + Interval::new(183, 183), + Interval::new(775, 776), + Interval::new(778, 778), + Interval::new(803, 804), + Interval::new(11836, 11836), + Interval::new(113664, 113770), + Interval::new(113776, 113788), + Interval::new(113792, 113800), + Interval::new(113808, 113817), + Interval::new(113820, 113827), +]; + +const EGYPTIAN_HIEROGLYPHS: [Interval; 2] = + [Interval::new(77824, 78933), Interval::new(78944, 82938)]; + +const ELBASAN: [Interval; 1] = [Interval::new(66816, 66855)]; + +const ELBASAN_EXTENSIONS: [Interval; 3] = [ + Interval::new(183, 183), + Interval::new(773, 773), + Interval::new(66816, 66855), +]; + +const ELYMAIC: [Interval; 1] = [Interval::new(69600, 69622)]; + +const ETHIOPIC: [Interval; 36] = [ + Interval::new(4608, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4957, 4988), + Interval::new(4992, 5017), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), +]; + +const ETHIOPIC_EXTENSIONS: [Interval; 37] = [ + Interval::new(782, 782), + Interval::new(4608, 4680), + Interval::new(4682, 4685), + Interval::new(4688, 4694), + Interval::new(4696, 4696), + Interval::new(4698, 4701), + Interval::new(4704, 4744), + Interval::new(4746, 4749), + Interval::new(4752, 4784), + Interval::new(4786, 4789), + Interval::new(4792, 4798), + Interval::new(4800, 4800), + Interval::new(4802, 4805), + Interval::new(4808, 4822), + Interval::new(4824, 4880), + Interval::new(4882, 4885), + Interval::new(4888, 4954), + Interval::new(4957, 4988), + Interval::new(4992, 5017), + Interval::new(11648, 11670), + Interval::new(11680, 11686), + Interval::new(11688, 11694), + Interval::new(11696, 11702), + Interval::new(11704, 11710), + Interval::new(11712, 11718), + Interval::new(11720, 11726), + Interval::new(11728, 11734), + Interval::new(11736, 11742), + Interval::new(43777, 43782), + Interval::new(43785, 43790), + Interval::new(43793, 43798), + Interval::new(43808, 43814), + Interval::new(43816, 43822), + Interval::new(124896, 124902), + Interval::new(124904, 124907), + Interval::new(124909, 124910), + Interval::new(124912, 124926), +]; + +const GARAY: [Interval; 3] = [ + Interval::new(68928, 68965), + Interval::new(68969, 68997), + Interval::new(69006, 69007), +]; + +const GARAY_EXTENSIONS: [Interval; 6] = [ + Interval::new(1548, 1548), + Interval::new(1563, 1563), + Interval::new(1567, 1567), + Interval::new(68928, 68965), + Interval::new(68969, 68997), + Interval::new(69006, 69007), +]; + +const GEORGIAN: [Interval; 10] = [ + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4346), + Interval::new(4348, 4351), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), +]; + +const GEORGIAN_EXTENSIONS: [Interval; 13] = [ + Interval::new(183, 183), + Interval::new(1417, 1417), + Interval::new(4256, 4293), + Interval::new(4295, 4295), + Interval::new(4301, 4301), + Interval::new(4304, 4351), + Interval::new(7312, 7354), + Interval::new(7357, 7359), + Interval::new(8282, 8282), + Interval::new(11520, 11557), + Interval::new(11559, 11559), + Interval::new(11565, 11565), + Interval::new(11825, 11825), +]; + +const GLAGOLITIC: [Interval; 6] = [ + Interval::new(11264, 11359), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), +]; + +const GLAGOLITIC_EXTENSIONS: [Interval; 16] = [ + Interval::new(183, 183), + Interval::new(771, 771), + Interval::new(773, 773), + Interval::new(1156, 1156), + Interval::new(1159, 1159), + Interval::new(1417, 1417), + Interval::new(4347, 4347), + Interval::new(8282, 8282), + Interval::new(11264, 11359), + Interval::new(11843, 11843), + Interval::new(42607, 42607), + Interval::new(122880, 122886), + Interval::new(122888, 122904), + Interval::new(122907, 122913), + Interval::new(122915, 122916), + Interval::new(122918, 122922), +]; + +const GUNJALA_GONDI: [Interval; 6] = [ + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73112), + Interval::new(73120, 73129), +]; + +const GUNJALA_GONDI_EXTENSIONS: [Interval; 8] = [ + Interval::new(183, 183), + Interval::new(2404, 2405), + Interval::new(73056, 73061), + Interval::new(73063, 73064), + Interval::new(73066, 73102), + Interval::new(73104, 73105), + Interval::new(73107, 73112), + Interval::new(73120, 73129), +]; + +const MASARAM_GONDI: [Interval; 7] = [ + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73031), + Interval::new(73040, 73049), +]; + +const MASARAM_GONDI_EXTENSIONS: [Interval; 8] = [ + Interval::new(2404, 2405), + Interval::new(72960, 72966), + Interval::new(72968, 72969), + Interval::new(72971, 73014), + Interval::new(73018, 73018), + Interval::new(73020, 73021), + Interval::new(73023, 73031), + Interval::new(73040, 73049), +]; + +const GOTHIC: [Interval; 1] = [Interval::new(66352, 66378)]; + +const GOTHIC_EXTENSIONS: [Interval; 5] = [ + Interval::new(183, 183), + Interval::new(772, 773), + Interval::new(776, 776), + Interval::new(817, 817), + Interval::new(66352, 66378), +]; + +const GRANTHA: [Interval; 15] = [ + Interval::new(70400, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70460, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70480, 70480), + Interval::new(70487, 70487), + Interval::new(70493, 70499), + Interval::new(70502, 70508), + Interval::new(70512, 70516), +]; + +const GRANTHA_EXTENSIONS: [Interval; 25] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(3046, 3059), + Interval::new(7376, 7376), + Interval::new(7378, 7379), + Interval::new(7410, 7412), + Interval::new(7416, 7417), + Interval::new(8432, 8432), + Interval::new(70400, 70403), + Interval::new(70405, 70412), + Interval::new(70415, 70416), + Interval::new(70419, 70440), + Interval::new(70442, 70448), + Interval::new(70450, 70451), + Interval::new(70453, 70457), + Interval::new(70459, 70468), + Interval::new(70471, 70472), + Interval::new(70475, 70477), + Interval::new(70480, 70480), + Interval::new(70487, 70487), + Interval::new(70493, 70499), + Interval::new(70502, 70508), + Interval::new(70512, 70516), + Interval::new(73680, 73681), + Interval::new(73683, 73683), +]; + +const GREEK: [Interval; 36] = [ + Interval::new(880, 883), + Interval::new(885, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(900, 900), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 993), + Interval::new(1008, 1023), + Interval::new(7462, 7466), + Interval::new(7517, 7521), + Interval::new(7526, 7530), + Interval::new(7615, 7615), + Interval::new(7936, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8132), + Interval::new(8134, 8147), + Interval::new(8150, 8155), + Interval::new(8157, 8175), + Interval::new(8178, 8180), + Interval::new(8182, 8190), + Interval::new(8486, 8486), + Interval::new(43877, 43877), + Interval::new(65856, 65934), + Interval::new(65952, 65952), + Interval::new(119296, 119365), +]; + +const GREEK_EXTENSIONS: [Interval; 44] = [ + Interval::new(183, 183), + Interval::new(768, 769), + Interval::new(772, 772), + Interval::new(774, 774), + Interval::new(776, 776), + Interval::new(787, 787), + Interval::new(834, 834), + Interval::new(837, 837), + Interval::new(880, 887), + Interval::new(890, 893), + Interval::new(895, 895), + Interval::new(900, 900), + Interval::new(902, 902), + Interval::new(904, 906), + Interval::new(908, 908), + Interval::new(910, 929), + Interval::new(931, 993), + Interval::new(1008, 1023), + Interval::new(7462, 7466), + Interval::new(7517, 7521), + Interval::new(7526, 7530), + Interval::new(7615, 7617), + Interval::new(7936, 7957), + Interval::new(7960, 7965), + Interval::new(7968, 8005), + Interval::new(8008, 8013), + Interval::new(8016, 8023), + Interval::new(8025, 8025), + Interval::new(8027, 8027), + Interval::new(8029, 8029), + Interval::new(8031, 8061), + Interval::new(8064, 8116), + Interval::new(8118, 8132), + Interval::new(8134, 8147), + Interval::new(8150, 8155), + Interval::new(8157, 8175), + Interval::new(8178, 8180), + Interval::new(8182, 8190), + Interval::new(8285, 8285), + Interval::new(8486, 8486), + Interval::new(43877, 43877), + Interval::new(65856, 65934), + Interval::new(65952, 65952), + Interval::new(119296, 119365), +]; + +const GUJARATI: [Interval; 14] = [ + Interval::new(2689, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2748, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2765), + Interval::new(2768, 2768), + Interval::new(2784, 2787), + Interval::new(2790, 2801), + Interval::new(2809, 2815), +]; + +const GUJARATI_EXTENSIONS: [Interval; 17] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(2689, 2691), + Interval::new(2693, 2701), + Interval::new(2703, 2705), + Interval::new(2707, 2728), + Interval::new(2730, 2736), + Interval::new(2738, 2739), + Interval::new(2741, 2745), + Interval::new(2748, 2757), + Interval::new(2759, 2761), + Interval::new(2763, 2765), + Interval::new(2768, 2768), + Interval::new(2784, 2787), + Interval::new(2790, 2801), + Interval::new(2809, 2815), + Interval::new(43056, 43065), +]; + +const GURUNG_KHEMA: [Interval; 1] = [Interval::new(90368, 90425)]; + +const GURUNG_KHEMA_EXTENSIONS: [Interval; 2] = + [Interval::new(2405, 2405), Interval::new(90368, 90425)]; + +const GURMUKHI: [Interval; 16] = [ + Interval::new(2561, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2620, 2620), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2662, 2678), +]; + +const GURMUKHI_EXTENSIONS: [Interval; 19] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(2561, 2563), + Interval::new(2565, 2570), + Interval::new(2575, 2576), + Interval::new(2579, 2600), + Interval::new(2602, 2608), + Interval::new(2610, 2611), + Interval::new(2613, 2614), + Interval::new(2616, 2617), + Interval::new(2620, 2620), + Interval::new(2622, 2626), + Interval::new(2631, 2632), + Interval::new(2635, 2637), + Interval::new(2641, 2641), + Interval::new(2649, 2652), + Interval::new(2654, 2654), + Interval::new(2662, 2678), + Interval::new(43056, 43065), +]; + +const HANGUL: [Interval; 14] = [ + Interval::new(4352, 4607), + Interval::new(12334, 12335), + Interval::new(12593, 12686), + Interval::new(12800, 12830), + Interval::new(12896, 12926), + Interval::new(43360, 43388), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(65440, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), +]; + +const HANGUL_EXTENSIONS: [Interval; 21] = [ + Interval::new(4352, 4607), + Interval::new(12289, 12291), + Interval::new(12296, 12305), + Interval::new(12307, 12319), + Interval::new(12334, 12336), + Interval::new(12343, 12343), + Interval::new(12539, 12539), + Interval::new(12593, 12686), + Interval::new(12800, 12830), + Interval::new(12896, 12926), + Interval::new(43360, 43388), + Interval::new(44032, 55203), + Interval::new(55216, 55238), + Interval::new(55243, 55291), + Interval::new(65093, 65094), + Interval::new(65377, 65381), + Interval::new(65440, 65470), + Interval::new(65474, 65479), + Interval::new(65482, 65487), + Interval::new(65490, 65495), + Interval::new(65498, 65500), +]; + +const HAN: [Interval; 21] = [ + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), + Interval::new(12293, 12293), + Interval::new(12295, 12295), + Interval::new(12321, 12329), + Interval::new(12344, 12347), + Interval::new(13312, 19903), + Interval::new(19968, 40959), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(94178, 94179), + Interval::new(94192, 94198), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +const HAN_EXTENSIONS: [Interval; 41] = [ + Interval::new(183, 183), + Interval::new(11904, 11929), + Interval::new(11931, 12019), + Interval::new(12032, 12245), + Interval::new(12272, 12287), + Interval::new(12289, 12291), + Interval::new(12293, 12305), + Interval::new(12307, 12319), + Interval::new(12321, 12333), + Interval::new(12336, 12336), + Interval::new(12343, 12351), + Interval::new(12539, 12539), + Interval::new(12688, 12703), + Interval::new(12736, 12773), + Interval::new(12783, 12783), + Interval::new(12832, 12871), + Interval::new(12928, 12976), + Interval::new(12992, 13003), + Interval::new(13055, 13055), + Interval::new(13144, 13168), + Interval::new(13179, 13183), + Interval::new(13280, 13310), + Interval::new(13312, 19903), + Interval::new(19968, 40959), + Interval::new(42752, 42759), + Interval::new(63744, 64109), + Interval::new(64112, 64217), + Interval::new(65093, 65094), + Interval::new(65377, 65381), + Interval::new(94178, 94179), + Interval::new(94192, 94198), + Interval::new(119648, 119665), + Interval::new(127568, 127569), + Interval::new(131072, 173791), + Interval::new(173824, 178205), + Interval::new(178208, 183981), + Interval::new(183984, 191456), + Interval::new(191472, 192093), + Interval::new(194560, 195101), + Interval::new(196608, 201546), + Interval::new(201552, 210041), +]; + +const HANUNOO: [Interval; 1] = [Interval::new(5920, 5940)]; + +const HANUNOO_EXTENSIONS: [Interval; 1] = [Interval::new(5920, 5942)]; + +const HATRAN: [Interval; 3] = [ + Interval::new(67808, 67826), + Interval::new(67828, 67829), + Interval::new(67835, 67839), +]; + +const HEBREW: [Interval; 9] = [ + Interval::new(1425, 1479), + Interval::new(1488, 1514), + Interval::new(1519, 1524), + Interval::new(64285, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64335), +]; + +const HEBREW_EXTENSIONS: [Interval; 10] = [ + Interval::new(775, 776), + Interval::new(1425, 1479), + Interval::new(1488, 1514), + Interval::new(1519, 1524), + Interval::new(64285, 64310), + Interval::new(64312, 64316), + Interval::new(64318, 64318), + Interval::new(64320, 64321), + Interval::new(64323, 64324), + Interval::new(64326, 64335), +]; + +const HIRAGANA: [Interval; 6] = [ + Interval::new(12353, 12438), + Interval::new(12445, 12447), + Interval::new(110593, 110879), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(127488, 127488), +]; + +const HIRAGANA_EXTENSIONS: [Interval; 17] = [ + Interval::new(12289, 12291), + Interval::new(12296, 12305), + Interval::new(12307, 12319), + Interval::new(12336, 12341), + Interval::new(12343, 12343), + Interval::new(12348, 12349), + Interval::new(12353, 12438), + Interval::new(12441, 12448), + Interval::new(12539, 12540), + Interval::new(65093, 65094), + Interval::new(65377, 65381), + Interval::new(65392, 65392), + Interval::new(65438, 65439), + Interval::new(110593, 110879), + Interval::new(110898, 110898), + Interval::new(110928, 110930), + Interval::new(127488, 127488), +]; + +const ANATOLIAN_HIEROGLYPHS: [Interval; 1] = [Interval::new(82944, 83526)]; + +const PAHAWH_HMONG: [Interval; 5] = [ + Interval::new(92928, 92997), + Interval::new(93008, 93017), + Interval::new(93019, 93025), + Interval::new(93027, 93047), + Interval::new(93053, 93071), +]; + +const NYIAKENG_PUACHUE_HMONG: [Interval; 4] = [ + Interval::new(123136, 123180), + Interval::new(123184, 123197), + Interval::new(123200, 123209), + Interval::new(123214, 123215), +]; + +const OLD_HUNGARIAN: [Interval; 3] = [ + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68858, 68863), +]; + +const OLD_HUNGARIAN_EXTENSIONS: [Interval; 7] = [ + Interval::new(8282, 8282), + Interval::new(8285, 8285), + Interval::new(11825, 11825), + Interval::new(11841, 11841), + Interval::new(68736, 68786), + Interval::new(68800, 68850), + Interval::new(68858, 68863), +]; + +const OLD_ITALIC: [Interval; 2] = [Interval::new(66304, 66339), Interval::new(66349, 66351)]; + +const JAVANESE: [Interval; 3] = [ + Interval::new(43392, 43469), + Interval::new(43472, 43481), + Interval::new(43486, 43487), +]; + +const JAVANESE_EXTENSIONS: [Interval; 3] = [ + Interval::new(43392, 43469), + Interval::new(43471, 43481), + Interval::new(43486, 43487), +]; + +const KAYAH_LI: [Interval; 2] = [Interval::new(43264, 43309), Interval::new(43311, 43311)]; + +const KAYAH_LI_EXTENSIONS: [Interval; 1] = [Interval::new(43264, 43311)]; + +const KATAKANA: [Interval; 14] = [ + Interval::new(12449, 12538), + Interval::new(12541, 12543), + Interval::new(12784, 12799), + Interval::new(13008, 13054), + Interval::new(13056, 13143), + Interval::new(65382, 65391), + Interval::new(65393, 65437), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110592), + Interval::new(110880, 110882), + Interval::new(110933, 110933), + Interval::new(110948, 110951), +]; + +const KATAKANA_EXTENSIONS: [Interval; 22] = [ + Interval::new(773, 773), + Interval::new(803, 803), + Interval::new(12289, 12291), + Interval::new(12296, 12305), + Interval::new(12307, 12319), + Interval::new(12336, 12341), + Interval::new(12343, 12343), + Interval::new(12348, 12349), + Interval::new(12441, 12444), + Interval::new(12448, 12543), + Interval::new(12784, 12799), + Interval::new(13008, 13054), + Interval::new(13056, 13143), + Interval::new(65093, 65094), + Interval::new(65377, 65439), + Interval::new(110576, 110579), + Interval::new(110581, 110587), + Interval::new(110589, 110590), + Interval::new(110592, 110592), + Interval::new(110880, 110882), + Interval::new(110933, 110933), + Interval::new(110948, 110951), +]; + +const KAWI: [Interval; 3] = [ + Interval::new(73472, 73488), + Interval::new(73490, 73530), + Interval::new(73534, 73562), +]; + +const KHAROSHTHI: [Interval; 8] = [ + Interval::new(68096, 68099), + Interval::new(68101, 68102), + Interval::new(68108, 68115), + Interval::new(68117, 68119), + Interval::new(68121, 68149), + Interval::new(68152, 68154), + Interval::new(68159, 68168), + Interval::new(68176, 68184), +]; + +const KHMER: [Interval; 4] = [ + Interval::new(6016, 6109), + Interval::new(6112, 6121), + Interval::new(6128, 6137), + Interval::new(6624, 6655), +]; + +const KHOJKI: [Interval; 2] = [Interval::new(70144, 70161), Interval::new(70163, 70209)]; + +const KHOJKI_EXTENSIONS: [Interval; 4] = [ + Interval::new(2790, 2799), + Interval::new(43056, 43065), + Interval::new(70144, 70161), + Interval::new(70163, 70209), +]; + +const KHITAN_SMALL_SCRIPT: [Interval; 3] = [ + Interval::new(94180, 94180), + Interval::new(101120, 101589), + Interval::new(101631, 101631), +]; + +const KANNADA: [Interval; 13] = [ + Interval::new(3200, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3260, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3292, 3294), + Interval::new(3296, 3299), + Interval::new(3302, 3311), + Interval::new(3313, 3315), +]; + +const KANNADA_EXTENSIONS: [Interval; 21] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(3200, 3212), + Interval::new(3214, 3216), + Interval::new(3218, 3240), + Interval::new(3242, 3251), + Interval::new(3253, 3257), + Interval::new(3260, 3268), + Interval::new(3270, 3272), + Interval::new(3274, 3277), + Interval::new(3285, 3286), + Interval::new(3292, 3294), + Interval::new(3296, 3299), + Interval::new(3302, 3311), + Interval::new(3313, 3315), + Interval::new(7376, 7376), + Interval::new(7378, 7379), + Interval::new(7386, 7386), + Interval::new(7410, 7410), + Interval::new(7412, 7412), + Interval::new(43056, 43061), +]; + +const KIRAT_RAI: [Interval; 1] = [Interval::new(93504, 93561)]; + +const KAITHI: [Interval; 2] = [Interval::new(69760, 69826), Interval::new(69837, 69837)]; + +const KAITHI_EXTENSIONS: [Interval; 5] = [ + Interval::new(2406, 2415), + Interval::new(11825, 11825), + Interval::new(43056, 43065), + Interval::new(69760, 69826), + Interval::new(69837, 69837), +]; + +const TAI_THAM: [Interval; 5] = [ + Interval::new(6688, 6750), + Interval::new(6752, 6780), + Interval::new(6783, 6793), + Interval::new(6800, 6809), + Interval::new(6816, 6829), +]; + +const LAO: [Interval; 11] = [ + Interval::new(3713, 3714), + Interval::new(3716, 3716), + Interval::new(3718, 3722), + Interval::new(3724, 3747), + Interval::new(3749, 3749), + Interval::new(3751, 3773), + Interval::new(3776, 3780), + Interval::new(3782, 3782), + Interval::new(3784, 3790), + Interval::new(3792, 3801), + Interval::new(3804, 3807), +]; + +const LATIN: [Interval; 36] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 696), + Interval::new(736, 740), + Interval::new(7424, 7461), + Interval::new(7468, 7516), + Interval::new(7522, 7525), + Interval::new(7531, 7543), + Interval::new(7545, 7614), + Interval::new(7680, 7935), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8490, 8491), + Interval::new(8498, 8498), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(11360, 11391), + Interval::new(42786, 42887), + Interval::new(42891, 42972), + Interval::new(42993, 43007), + Interval::new(43824, 43866), + Interval::new(43868, 43876), + Interval::new(43878, 43881), + Interval::new(64256, 64262), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(122624, 122654), + Interval::new(122661, 122666), +]; + +const LATIN_EXTENSIONS: [Interval; 61] = [ + Interval::new(65, 90), + Interval::new(97, 122), + Interval::new(170, 170), + Interval::new(183, 183), + Interval::new(186, 186), + Interval::new(192, 214), + Interval::new(216, 246), + Interval::new(248, 696), + Interval::new(700, 700), + Interval::new(711, 711), + Interval::new(713, 715), + Interval::new(717, 717), + Interval::new(727, 727), + Interval::new(729, 729), + Interval::new(736, 740), + Interval::new(768, 782), + Interval::new(784, 785), + Interval::new(787, 787), + Interval::new(803, 805), + Interval::new(813, 814), + Interval::new(816, 817), + Interval::new(856, 856), + Interval::new(862, 862), + Interval::new(867, 879), + Interval::new(1157, 1158), + Interval::new(2385, 2386), + Interval::new(4347, 4347), + Interval::new(7424, 7461), + Interval::new(7468, 7516), + Interval::new(7522, 7525), + Interval::new(7531, 7543), + Interval::new(7545, 7614), + Interval::new(7672, 7672), + Interval::new(7680, 7935), + Interval::new(8239, 8239), + Interval::new(8305, 8305), + Interval::new(8319, 8319), + Interval::new(8336, 8348), + Interval::new(8432, 8432), + Interval::new(8490, 8491), + Interval::new(8498, 8498), + Interval::new(8526, 8526), + Interval::new(8544, 8584), + Interval::new(11360, 11391), + Interval::new(11799, 11799), + Interval::new(42752, 42759), + Interval::new(42786, 42887), + Interval::new(42891, 42972), + Interval::new(42993, 43007), + Interval::new(43310, 43310), + Interval::new(43824, 43866), + Interval::new(43868, 43876), + Interval::new(43878, 43881), + Interval::new(64256, 64262), + Interval::new(65313, 65338), + Interval::new(65345, 65370), + Interval::new(67456, 67461), + Interval::new(67463, 67504), + Interval::new(67506, 67514), + Interval::new(122624, 122654), + Interval::new(122661, 122666), +]; + +const LEPCHA: [Interval; 3] = [ + Interval::new(7168, 7223), + Interval::new(7227, 7241), + Interval::new(7245, 7247), +]; + +const LIMBU: [Interval; 5] = [ + Interval::new(6400, 6430), + Interval::new(6432, 6443), + Interval::new(6448, 6459), + Interval::new(6464, 6464), + Interval::new(6468, 6479), +]; + +const LIMBU_EXTENSIONS: [Interval; 6] = [ + Interval::new(2405, 2405), + Interval::new(6400, 6430), + Interval::new(6432, 6443), + Interval::new(6448, 6459), + Interval::new(6464, 6464), + Interval::new(6468, 6479), +]; + +const LINEAR_A: [Interval; 3] = [ + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), +]; + +const LINEAR_A_EXTENSIONS: [Interval; 4] = [ + Interval::new(65799, 65843), + Interval::new(67072, 67382), + Interval::new(67392, 67413), + Interval::new(67424, 67431), +]; + +const LINEAR_B: [Interval; 7] = [ + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), +]; + +const LINEAR_B_EXTENSIONS: [Interval; 10] = [ + Interval::new(65536, 65547), + Interval::new(65549, 65574), + Interval::new(65576, 65594), + Interval::new(65596, 65597), + Interval::new(65599, 65613), + Interval::new(65616, 65629), + Interval::new(65664, 65786), + Interval::new(65792, 65794), + Interval::new(65799, 65843), + Interval::new(65847, 65855), +]; + +const LISU: [Interval; 2] = [Interval::new(42192, 42239), Interval::new(73648, 73648)]; + +const LISU_EXTENSIONS: [Interval; 5] = [ + Interval::new(700, 700), + Interval::new(717, 717), + Interval::new(12298, 12299), + Interval::new(42192, 42239), + Interval::new(73648, 73648), +]; + +const LYCIAN: [Interval; 1] = [Interval::new(66176, 66204)]; + +const LYCIAN_EXTENSIONS: [Interval; 2] = [Interval::new(8282, 8282), Interval::new(66176, 66204)]; + +const LYDIAN: [Interval; 2] = [Interval::new(67872, 67897), Interval::new(67903, 67903)]; + +const LYDIAN_EXTENSIONS: [Interval; 4] = [ + Interval::new(183, 183), + Interval::new(11825, 11825), + Interval::new(67872, 67897), + Interval::new(67903, 67903), +]; + +const MAHAJANI: [Interval; 1] = [Interval::new(69968, 70006)]; + +const MAHAJANI_EXTENSIONS: [Interval; 4] = [ + Interval::new(183, 183), + Interval::new(2404, 2415), + Interval::new(43056, 43065), + Interval::new(69968, 70006), +]; + +const MAKASAR: [Interval; 1] = [Interval::new(73440, 73464)]; + +const MANDAIC: [Interval; 2] = [Interval::new(2112, 2139), Interval::new(2142, 2142)]; + +const MANDAIC_EXTENSIONS: [Interval; 3] = [ + Interval::new(1600, 1600), + Interval::new(2112, 2139), + Interval::new(2142, 2142), +]; + +const MANICHAEAN: [Interval; 2] = [Interval::new(68288, 68326), Interval::new(68331, 68342)]; + +const MANICHAEAN_EXTENSIONS: [Interval; 3] = [ + Interval::new(1600, 1600), + Interval::new(68288, 68326), + Interval::new(68331, 68342), +]; + +const MARCHEN: [Interval; 3] = [ + Interval::new(72816, 72847), + Interval::new(72850, 72871), + Interval::new(72873, 72886), +]; + +const MEDEFAIDRIN: [Interval; 1] = [Interval::new(93760, 93850)]; + +const MENDE_KIKAKUI: [Interval; 2] = [Interval::new(124928, 125124), Interval::new(125127, 125142)]; + +const MEROITIC_CURSIVE: [Interval; 3] = [ + Interval::new(68000, 68023), + Interval::new(68028, 68047), + Interval::new(68050, 68095), +]; + +const MEROITIC_HIEROGLYPHS: [Interval; 1] = [Interval::new(67968, 67999)]; + +const MEROITIC_HIEROGLYPHS_EXTENSIONS: [Interval; 2] = + [Interval::new(8285, 8285), Interval::new(67968, 67999)]; + +const MALAYALAM: [Interval; 7] = [ + Interval::new(3328, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3407), + Interval::new(3412, 3427), + Interval::new(3430, 3455), +]; + +const MALAYALAM_EXTENSIONS: [Interval; 12] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(3328, 3340), + Interval::new(3342, 3344), + Interval::new(3346, 3396), + Interval::new(3398, 3400), + Interval::new(3402, 3407), + Interval::new(3412, 3427), + Interval::new(3430, 3455), + Interval::new(7386, 7386), + Interval::new(7410, 7410), + Interval::new(43056, 43058), +]; + +const MODI: [Interval; 2] = [Interval::new(71168, 71236), Interval::new(71248, 71257)]; + +const MODI_EXTENSIONS: [Interval; 3] = [ + Interval::new(43056, 43065), + Interval::new(71168, 71236), + Interval::new(71248, 71257), +]; + +const MONGOLIAN: [Interval; 6] = [ + Interval::new(6144, 6145), + Interval::new(6148, 6148), + Interval::new(6150, 6169), + Interval::new(6176, 6264), + Interval::new(6272, 6314), + Interval::new(71264, 71276), +]; + +const MONGOLIAN_EXTENSIONS: [Interval; 7] = [ + Interval::new(6144, 6169), + Interval::new(6176, 6264), + Interval::new(6272, 6314), + Interval::new(8239, 8239), + Interval::new(12289, 12290), + Interval::new(12296, 12299), + Interval::new(71264, 71276), +]; + +const MRO: [Interval; 3] = [ + Interval::new(92736, 92766), + Interval::new(92768, 92777), + Interval::new(92782, 92783), +]; + +const MEETEI_MAYEK: [Interval; 3] = [ + Interval::new(43744, 43766), + Interval::new(43968, 44013), + Interval::new(44016, 44025), +]; + +const MULTANI: [Interval; 5] = [ + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70313), +]; + +const MULTANI_EXTENSIONS: [Interval; 6] = [ + Interval::new(2662, 2671), + Interval::new(70272, 70278), + Interval::new(70280, 70280), + Interval::new(70282, 70285), + Interval::new(70287, 70301), + Interval::new(70303, 70313), +]; + +const MYANMAR: [Interval; 4] = [ + Interval::new(4096, 4255), + Interval::new(43488, 43518), + Interval::new(43616, 43647), + Interval::new(71376, 71395), +]; + +const MYANMAR_EXTENSIONS: [Interval; 5] = [ + Interval::new(4096, 4255), + Interval::new(43310, 43310), + Interval::new(43488, 43518), + Interval::new(43616, 43647), + Interval::new(71376, 71395), +]; + +const NAG_MUNDARI: [Interval; 1] = [Interval::new(124112, 124153)]; + +const NANDINAGARI: [Interval; 3] = [ + Interval::new(72096, 72103), + Interval::new(72106, 72151), + Interval::new(72154, 72164), +]; + +const NANDINAGARI_EXTENSIONS: [Interval; 10] = [ + Interval::new(2385, 2385), + Interval::new(2404, 2405), + Interval::new(3302, 3311), + Interval::new(7401, 7401), + Interval::new(7410, 7410), + Interval::new(7418, 7418), + Interval::new(43056, 43061), + Interval::new(72096, 72103), + Interval::new(72106, 72151), + Interval::new(72154, 72164), +]; + +const OLD_NORTH_ARABIAN: [Interval; 1] = [Interval::new(68224, 68255)]; + +const NABATAEAN: [Interval; 2] = [Interval::new(67712, 67742), Interval::new(67751, 67759)]; + +const NEWA: [Interval; 2] = [Interval::new(70656, 70747), Interval::new(70749, 70753)]; + +const NEWA_EXTENSIONS: [Interval; 9] = [ + Interval::new(2385, 2386), + Interval::new(7381, 7381), + Interval::new(7383, 7384), + Interval::new(7394, 7394), + Interval::new(7401, 7401), + Interval::new(7403, 7403), + Interval::new(7405, 7405), + Interval::new(70656, 70747), + Interval::new(70749, 70753), +]; + +const NKO: [Interval; 2] = [Interval::new(1984, 2042), Interval::new(2045, 2047)]; + +const NKO_EXTENSIONS: [Interval; 6] = [ + Interval::new(1548, 1548), + Interval::new(1563, 1563), + Interval::new(1567, 1567), + Interval::new(1984, 2042), + Interval::new(2045, 2047), + Interval::new(64830, 64831), +]; + +const NUSHU: [Interval; 2] = [Interval::new(94177, 94177), Interval::new(110960, 111355)]; + +const OGHAM: [Interval; 1] = [Interval::new(5760, 5788)]; + +const OL_CHIKI: [Interval; 1] = [Interval::new(7248, 7295)]; + +const OL_ONAL: [Interval; 2] = [Interval::new(124368, 124410), Interval::new(124415, 124415)]; + +const OL_ONAL_EXTENSIONS: [Interval; 3] = [ + Interval::new(2404, 2405), + Interval::new(124368, 124410), + Interval::new(124415, 124415), +]; + +const OLD_TURKIC: [Interval; 1] = [Interval::new(68608, 68680)]; + +const OLD_TURKIC_EXTENSIONS: [Interval; 3] = [ + Interval::new(8282, 8282), + Interval::new(11824, 11824), + Interval::new(68608, 68680), +]; + +const ORIYA: [Interval; 14] = [ + Interval::new(2817, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2876, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2893), + Interval::new(2901, 2903), + Interval::new(2908, 2909), + Interval::new(2911, 2915), + Interval::new(2918, 2935), +]; + +const ORIYA_EXTENSIONS: [Interval; 18] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(2817, 2819), + Interval::new(2821, 2828), + Interval::new(2831, 2832), + Interval::new(2835, 2856), + Interval::new(2858, 2864), + Interval::new(2866, 2867), + Interval::new(2869, 2873), + Interval::new(2876, 2884), + Interval::new(2887, 2888), + Interval::new(2891, 2893), + Interval::new(2901, 2903), + Interval::new(2908, 2909), + Interval::new(2911, 2915), + Interval::new(2918, 2935), + Interval::new(7386, 7386), + Interval::new(7410, 7410), +]; + +const OSAGE: [Interval; 2] = [Interval::new(66736, 66771), Interval::new(66776, 66811)]; + +const OSAGE_EXTENSIONS: [Interval; 6] = [ + Interval::new(769, 769), + Interval::new(772, 772), + Interval::new(779, 779), + Interval::new(856, 856), + Interval::new(66736, 66771), + Interval::new(66776, 66811), +]; + +const OSMANYA: [Interval; 2] = [Interval::new(66688, 66717), Interval::new(66720, 66729)]; + +const OLD_UYGHUR: [Interval; 1] = [Interval::new(69488, 69513)]; + +const OLD_UYGHUR_EXTENSIONS: [Interval; 3] = [ + Interval::new(1600, 1600), + Interval::new(68338, 68338), + Interval::new(69488, 69513), +]; + +const PALMYRENE: [Interval; 1] = [Interval::new(67680, 67711)]; + +const PAU_CIN_HAU: [Interval; 1] = [Interval::new(72384, 72440)]; + +const OLD_PERMIC: [Interval; 1] = [Interval::new(66384, 66426)]; + +const OLD_PERMIC_EXTENSIONS: [Interval; 6] = [ + Interval::new(183, 183), + Interval::new(768, 768), + Interval::new(774, 776), + Interval::new(787, 787), + Interval::new(1155, 1155), + Interval::new(66384, 66426), +]; + +const PHAGS_PA: [Interval; 1] = [Interval::new(43072, 43127)]; + +const PHAGS_PA_EXTENSIONS: [Interval; 5] = [ + Interval::new(6146, 6147), + Interval::new(6149, 6149), + Interval::new(8239, 8239), + Interval::new(12290, 12290), + Interval::new(43072, 43127), +]; + +const INSCRIPTIONAL_PAHLAVI: [Interval; 2] = + [Interval::new(68448, 68466), Interval::new(68472, 68479)]; + +const PSALTER_PAHLAVI: [Interval; 3] = [ + Interval::new(68480, 68497), + Interval::new(68505, 68508), + Interval::new(68521, 68527), +]; + +const PSALTER_PAHLAVI_EXTENSIONS: [Interval; 4] = [ + Interval::new(1600, 1600), + Interval::new(68480, 68497), + Interval::new(68505, 68508), + Interval::new(68521, 68527), +]; + +const PHOENICIAN: [Interval; 2] = [Interval::new(67840, 67867), Interval::new(67871, 67871)]; + +const MIAO: [Interval; 3] = [ + Interval::new(93952, 94026), + Interval::new(94031, 94087), + Interval::new(94095, 94111), +]; + +const INSCRIPTIONAL_PARTHIAN: [Interval; 2] = + [Interval::new(68416, 68437), Interval::new(68440, 68447)]; + +const REJANG: [Interval; 2] = [Interval::new(43312, 43347), Interval::new(43359, 43359)]; + +const HANIFI_ROHINGYA: [Interval; 2] = [Interval::new(68864, 68903), Interval::new(68912, 68921)]; + +const HANIFI_ROHINGYA_EXTENSIONS: [Interval; 7] = [ + Interval::new(1548, 1548), + Interval::new(1563, 1563), + Interval::new(1567, 1567), + Interval::new(1600, 1600), + Interval::new(1748, 1748), + Interval::new(68864, 68903), + Interval::new(68912, 68921), +]; + +const RUNIC: [Interval; 2] = [Interval::new(5792, 5866), Interval::new(5870, 5880)]; + +const RUNIC_EXTENSIONS: [Interval; 1] = [Interval::new(5792, 5880)]; + +const SAMARITAN: [Interval; 2] = [Interval::new(2048, 2093), Interval::new(2096, 2110)]; + +const SAMARITAN_EXTENSIONS: [Interval; 3] = [ + Interval::new(2048, 2093), + Interval::new(2096, 2110), + Interval::new(11825, 11825), +]; + +const OLD_SOUTH_ARABIAN: [Interval; 1] = [Interval::new(68192, 68223)]; + +const SAURASHTRA: [Interval; 2] = [Interval::new(43136, 43205), Interval::new(43214, 43225)]; + +const SIGNWRITING: [Interval; 3] = [ + Interval::new(120832, 121483), + Interval::new(121499, 121503), + Interval::new(121505, 121519), +]; + +const SHAVIAN: [Interval; 1] = [Interval::new(66640, 66687)]; + +const SHAVIAN_EXTENSIONS: [Interval; 2] = [Interval::new(183, 183), Interval::new(66640, 66687)]; + +const SHARADA: [Interval; 2] = [Interval::new(70016, 70111), Interval::new(72544, 72551)]; + +const SHARADA_EXTENSIONS: [Interval; 11] = [ + Interval::new(2385, 2385), + Interval::new(7383, 7383), + Interval::new(7385, 7385), + Interval::new(7388, 7389), + Interval::new(7392, 7392), + Interval::new(7402, 7402), + Interval::new(7405, 7405), + Interval::new(43056, 43061), + Interval::new(43064, 43064), + Interval::new(70016, 70111), + Interval::new(72544, 72551), +]; + +const SIDDHAM: [Interval; 2] = [Interval::new(71040, 71093), Interval::new(71096, 71133)]; + +const SIDETIC: [Interval; 1] = [Interval::new(67904, 67929)]; + +const KHUDAWADI: [Interval; 2] = [Interval::new(70320, 70378), Interval::new(70384, 70393)]; + +const KHUDAWADI_EXTENSIONS: [Interval; 4] = [ + Interval::new(2404, 2405), + Interval::new(43056, 43065), + Interval::new(70320, 70378), + Interval::new(70384, 70393), +]; + +const SINHALA: [Interval; 13] = [ + Interval::new(3457, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3530, 3530), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3558, 3567), + Interval::new(3570, 3572), + Interval::new(70113, 70132), +]; + +const SINHALA_EXTENSIONS: [Interval; 15] = [ + Interval::new(2404, 2405), + Interval::new(3457, 3459), + Interval::new(3461, 3478), + Interval::new(3482, 3505), + Interval::new(3507, 3515), + Interval::new(3517, 3517), + Interval::new(3520, 3526), + Interval::new(3530, 3530), + Interval::new(3535, 3540), + Interval::new(3542, 3542), + Interval::new(3544, 3551), + Interval::new(3558, 3567), + Interval::new(3570, 3572), + Interval::new(7410, 7410), + Interval::new(70113, 70132), +]; + +const SOGDIAN: [Interval; 1] = [Interval::new(69424, 69465)]; + +const SOGDIAN_EXTENSIONS: [Interval; 2] = [Interval::new(1600, 1600), Interval::new(69424, 69465)]; + +const OLD_SOGDIAN: [Interval; 1] = [Interval::new(69376, 69415)]; + +const SORA_SOMPENG: [Interval; 2] = [Interval::new(69840, 69864), Interval::new(69872, 69881)]; + +const SOYOMBO: [Interval; 1] = [Interval::new(72272, 72354)]; + +const SUNDANESE: [Interval; 2] = [Interval::new(7040, 7103), Interval::new(7360, 7367)]; + +const SUNUWAR: [Interval; 2] = [Interval::new(72640, 72673), Interval::new(72688, 72697)]; + +const SUNUWAR_EXTENSIONS: [Interval; 8] = [ + Interval::new(768, 769), + Interval::new(771, 771), + Interval::new(781, 781), + Interval::new(784, 784), + Interval::new(813, 813), + Interval::new(817, 817), + Interval::new(72640, 72673), + Interval::new(72688, 72697), +]; + +const SYLOTI_NAGRI: [Interval; 1] = [Interval::new(43008, 43052)]; + +const SYLOTI_NAGRI_EXTENSIONS: [Interval; 3] = [ + Interval::new(2404, 2405), + Interval::new(2534, 2543), + Interval::new(43008, 43052), +]; + +const SYRIAC: [Interval; 4] = [ + Interval::new(1792, 1805), + Interval::new(1807, 1866), + Interval::new(1869, 1871), + Interval::new(2144, 2154), +]; + +const SYRIAC_EXTENSIONS: [Interval; 18] = [ + Interval::new(771, 772), + Interval::new(775, 776), + Interval::new(778, 778), + Interval::new(803, 805), + Interval::new(813, 814), + Interval::new(816, 817), + Interval::new(1548, 1548), + Interval::new(1563, 1564), + Interval::new(1567, 1567), + Interval::new(1600, 1600), + Interval::new(1611, 1621), + Interval::new(1648, 1648), + Interval::new(1792, 1805), + Interval::new(1807, 1866), + Interval::new(1869, 1871), + Interval::new(2144, 2154), + Interval::new(7672, 7672), + Interval::new(7674, 7674), +]; + +const TAGBANWA: [Interval; 3] = [ + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6002, 6003), +]; + +const TAGBANWA_EXTENSIONS: [Interval; 4] = [ + Interval::new(5941, 5942), + Interval::new(5984, 5996), + Interval::new(5998, 6000), + Interval::new(6002, 6003), +]; + +const TAKRI: [Interval; 2] = [Interval::new(71296, 71353), Interval::new(71360, 71369)]; + +const TAKRI_EXTENSIONS: [Interval; 4] = [ + Interval::new(2404, 2405), + Interval::new(43056, 43065), + Interval::new(71296, 71353), + Interval::new(71360, 71369), +]; + +const TAI_LE: [Interval; 2] = [Interval::new(6480, 6509), Interval::new(6512, 6516)]; + +const TAI_LE_EXTENSIONS: [Interval; 6] = [ + Interval::new(768, 769), + Interval::new(775, 776), + Interval::new(780, 780), + Interval::new(4160, 4169), + Interval::new(6480, 6509), + Interval::new(6512, 6516), +]; + +const NEW_TAI_LUE: [Interval; 4] = [ + Interval::new(6528, 6571), + Interval::new(6576, 6601), + Interval::new(6608, 6618), + Interval::new(6622, 6623), +]; + +const TAMIL: [Interval; 18] = [ + Interval::new(2946, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3021), + Interval::new(3024, 3024), + Interval::new(3031, 3031), + Interval::new(3046, 3066), + Interval::new(73664, 73713), + Interval::new(73727, 73727), +]; + +const TAMIL_EXTENSIONS: [Interval; 25] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(2946, 2947), + Interval::new(2949, 2954), + Interval::new(2958, 2960), + Interval::new(2962, 2965), + Interval::new(2969, 2970), + Interval::new(2972, 2972), + Interval::new(2974, 2975), + Interval::new(2979, 2980), + Interval::new(2984, 2986), + Interval::new(2990, 3001), + Interval::new(3006, 3010), + Interval::new(3014, 3016), + Interval::new(3018, 3021), + Interval::new(3024, 3024), + Interval::new(3031, 3031), + Interval::new(3046, 3066), + Interval::new(7386, 7386), + Interval::new(43251, 43251), + Interval::new(70401, 70401), + Interval::new(70403, 70403), + Interval::new(70459, 70460), + Interval::new(73664, 73713), + Interval::new(73727, 73727), +]; + +const TANGUT: [Interval; 4] = [ + Interval::new(94176, 94176), + Interval::new(94208, 101119), + Interval::new(101632, 101662), + Interval::new(101760, 101874), +]; + +const TANGUT_EXTENSIONS: [Interval; 6] = [ + Interval::new(12272, 12287), + Interval::new(12783, 12783), + Interval::new(94176, 94176), + Interval::new(94208, 101119), + Interval::new(101632, 101662), + Interval::new(101760, 101874), +]; + +const TAI_VIET: [Interval; 2] = [Interval::new(43648, 43714), Interval::new(43739, 43743)]; + +const TAI_YO: [Interval; 3] = [ + Interval::new(124608, 124638), + Interval::new(124640, 124661), + Interval::new(124670, 124671), +]; + +const TELUGU: [Interval; 13] = [ + Interval::new(3072, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3132, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3171), + Interval::new(3174, 3183), + Interval::new(3191, 3199), +]; + +const TELUGU_EXTENSIONS: [Interval; 19] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(3072, 3084), + Interval::new(3086, 3088), + Interval::new(3090, 3112), + Interval::new(3114, 3129), + Interval::new(3132, 3140), + Interval::new(3142, 3144), + Interval::new(3146, 3149), + Interval::new(3157, 3158), + Interval::new(3160, 3162), + Interval::new(3164, 3165), + Interval::new(3168, 3171), + Interval::new(3174, 3183), + Interval::new(3191, 3199), + Interval::new(7381, 7382), + Interval::new(7384, 7384), + Interval::new(7386, 7386), + Interval::new(7410, 7410), +]; + +const TIFINAGH: [Interval; 3] = [ + Interval::new(11568, 11623), + Interval::new(11631, 11632), + Interval::new(11647, 11647), +]; + +const TIFINAGH_EXTENSIONS: [Interval; 7] = [ + Interval::new(770, 770), + Interval::new(772, 772), + Interval::new(774, 777), + Interval::new(803, 803), + Interval::new(11568, 11623), + Interval::new(11631, 11632), + Interval::new(11647, 11647), +]; + +const TAGALOG: [Interval; 2] = [Interval::new(5888, 5909), Interval::new(5919, 5919)]; + +const TAGALOG_EXTENSIONS: [Interval; 3] = [ + Interval::new(5888, 5909), + Interval::new(5919, 5919), + Interval::new(5941, 5942), +]; + +const THAANA: [Interval; 1] = [Interval::new(1920, 1969)]; + +const THAANA_EXTENSIONS: [Interval; 7] = [ + Interval::new(1548, 1548), + Interval::new(1563, 1564), + Interval::new(1567, 1567), + Interval::new(1632, 1641), + Interval::new(1920, 1969), + Interval::new(65010, 65010), + Interval::new(65021, 65021), +]; + +const THAI: [Interval; 2] = [Interval::new(3585, 3642), Interval::new(3648, 3675)]; + +const THAI_EXTENSIONS: [Interval; 6] = [ + Interval::new(700, 700), + Interval::new(727, 727), + Interval::new(771, 771), + Interval::new(817, 817), + Interval::new(3585, 3642), + Interval::new(3648, 3675), +]; + +const TIBETAN: [Interval; 7] = [ + Interval::new(3840, 3911), + Interval::new(3913, 3948), + Interval::new(3953, 3991), + Interval::new(3993, 4028), + Interval::new(4030, 4044), + Interval::new(4046, 4052), + Interval::new(4057, 4058), +]; + +const TIBETAN_EXTENSIONS: [Interval; 8] = [ + Interval::new(3840, 3911), + Interval::new(3913, 3948), + Interval::new(3953, 3991), + Interval::new(3993, 4028), + Interval::new(4030, 4044), + Interval::new(4046, 4052), + Interval::new(4057, 4058), + Interval::new(12296, 12299), +]; + +const TIRHUTA: [Interval; 2] = [Interval::new(70784, 70855), Interval::new(70864, 70873)]; + +const TIRHUTA_EXTENSIONS: [Interval; 8] = [ + Interval::new(2385, 2386), + Interval::new(2404, 2405), + Interval::new(7381, 7381), + Interval::new(7394, 7394), + Interval::new(7410, 7410), + Interval::new(43056, 43065), + Interval::new(70784, 70855), + Interval::new(70864, 70873), +]; + +const TANGSA: [Interval; 2] = [Interval::new(92784, 92862), Interval::new(92864, 92873)]; + +const TODHRI: [Interval; 1] = [Interval::new(67008, 67059)]; + +const TODHRI_EXTENSIONS: [Interval; 7] = [ + Interval::new(769, 769), + Interval::new(772, 772), + Interval::new(775, 775), + Interval::new(785, 785), + Interval::new(787, 787), + Interval::new(862, 862), + Interval::new(67008, 67059), +]; + +const TOLONG_SIKI: [Interval; 2] = [Interval::new(73136, 73179), Interval::new(73184, 73193)]; + +const TOTO: [Interval; 1] = [Interval::new(123536, 123566)]; + +const TOTO_EXTENSIONS: [Interval; 2] = [Interval::new(700, 700), Interval::new(123536, 123566)]; + +const TULU_TIGALARI: [Interval; 11] = [ + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70613), + Interval::new(70615, 70616), + Interval::new(70625, 70626), +]; + +const TULU_TIGALARI_EXTENSIONS: [Interval; 16] = [ + Interval::new(3302, 3311), + Interval::new(7410, 7410), + Interval::new(7412, 7412), + Interval::new(43056, 43061), + Interval::new(43249, 43249), + Interval::new(70528, 70537), + Interval::new(70539, 70539), + Interval::new(70542, 70542), + Interval::new(70544, 70581), + Interval::new(70583, 70592), + Interval::new(70594, 70594), + Interval::new(70597, 70597), + Interval::new(70599, 70602), + Interval::new(70604, 70613), + Interval::new(70615, 70616), + Interval::new(70625, 70626), +]; + +const UGARITIC: [Interval; 2] = [Interval::new(66432, 66461), Interval::new(66463, 66463)]; + +const VAI: [Interval; 1] = [Interval::new(42240, 42539)]; + +const VITHKUQI: [Interval; 8] = [ + Interval::new(66928, 66938), + Interval::new(66940, 66954), + Interval::new(66956, 66962), + Interval::new(66964, 66965), + Interval::new(66967, 66977), + Interval::new(66979, 66993), + Interval::new(66995, 67001), + Interval::new(67003, 67004), +]; + +const WARANG_CITI: [Interval; 2] = [Interval::new(71840, 71922), Interval::new(71935, 71935)]; + +const WANCHO: [Interval; 2] = [Interval::new(123584, 123641), Interval::new(123647, 123647)]; + +const OLD_PERSIAN: [Interval; 2] = [Interval::new(66464, 66499), Interval::new(66504, 66517)]; + +const CUNEIFORM: [Interval; 4] = [ + Interval::new(73728, 74649), + Interval::new(74752, 74862), + Interval::new(74864, 74868), + Interval::new(74880, 75075), +]; + +const YEZIDI: [Interval; 3] = [ + Interval::new(69248, 69289), + Interval::new(69291, 69293), + Interval::new(69296, 69297), +]; + +const YEZIDI_EXTENSIONS: [Interval; 7] = [ + Interval::new(1548, 1548), + Interval::new(1563, 1563), + Interval::new(1567, 1567), + Interval::new(1632, 1641), + Interval::new(69248, 69289), + Interval::new(69291, 69293), + Interval::new(69296, 69297), +]; + +const YI: [Interval; 2] = [Interval::new(40960, 42124), Interval::new(42128, 42182)]; + +const YI_EXTENSIONS: [Interval; 7] = [ + Interval::new(12289, 12290), + Interval::new(12296, 12305), + Interval::new(12308, 12315), + Interval::new(12539, 12539), + Interval::new(40960, 42124), + Interval::new(42128, 42182), + Interval::new(65377, 65381), +]; + +const ZANABAZAR_SQUARE: [Interval; 1] = [Interval::new(72192, 72263)]; + +const INHERITED: [Interval; 30] = [ + Interval::new(768, 879), + Interval::new(1157, 1158), + Interval::new(1611, 1621), + Interval::new(1648, 1648), + Interval::new(2385, 2388), + Interval::new(6832, 6877), + Interval::new(6880, 6891), + Interval::new(7376, 7378), + Interval::new(7380, 7392), + Interval::new(7394, 7400), + Interval::new(7405, 7405), + Interval::new(7412, 7412), + Interval::new(7416, 7417), + Interval::new(7616, 7679), + Interval::new(8204, 8205), + Interval::new(8400, 8432), + Interval::new(12330, 12333), + Interval::new(12441, 12442), + Interval::new(65024, 65039), + Interval::new(65056, 65069), + Interval::new(66045, 66045), + Interval::new(66272, 66272), + Interval::new(70459, 70459), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119143, 119145), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(917760, 917999), +]; + +const INHERITED_EXTENSIONS: [Interval; 28] = [ + Interval::new(783, 783), + Interval::new(786, 786), + Interval::new(788, 802), + Interval::new(806, 812), + Interval::new(815, 815), + Interval::new(818, 833), + Interval::new(835, 836), + Interval::new(838, 855), + Interval::new(857, 861), + Interval::new(863, 866), + Interval::new(2387, 2388), + Interval::new(6832, 6877), + Interval::new(6880, 6891), + Interval::new(7618, 7671), + Interval::new(7673, 7673), + Interval::new(7675, 7679), + Interval::new(8204, 8205), + Interval::new(8400, 8431), + Interval::new(65024, 65039), + Interval::new(65056, 65069), + Interval::new(66045, 66045), + Interval::new(118528, 118573), + Interval::new(118576, 118598), + Interval::new(119143, 119145), + Interval::new(119163, 119170), + Interval::new(119173, 119179), + Interval::new(119210, 119213), + Interval::new(917760, 917999), +]; + +const COMMON: [Interval; 176] = [ + Interval::new(0, 64), + Interval::new(91, 96), + Interval::new(123, 169), + Interval::new(171, 185), + Interval::new(187, 191), + Interval::new(215, 215), + Interval::new(247, 247), + Interval::new(697, 735), + Interval::new(741, 745), + Interval::new(748, 767), + Interval::new(884, 884), + Interval::new(894, 894), + Interval::new(901, 901), + Interval::new(903, 903), + Interval::new(1541, 1541), + Interval::new(1548, 1548), + Interval::new(1563, 1563), + Interval::new(1567, 1567), + Interval::new(1600, 1600), + Interval::new(1757, 1757), + Interval::new(2274, 2274), + Interval::new(2404, 2405), + Interval::new(3647, 3647), + Interval::new(4053, 4056), + Interval::new(4347, 4347), + Interval::new(5867, 5869), + Interval::new(5941, 5942), + Interval::new(6146, 6147), + Interval::new(6149, 6149), + Interval::new(7379, 7379), + Interval::new(7393, 7393), + Interval::new(7401, 7404), + Interval::new(7406, 7411), + Interval::new(7413, 7415), + Interval::new(7418, 7418), + Interval::new(8192, 8203), + Interval::new(8206, 8292), + Interval::new(8294, 8304), + Interval::new(8308, 8318), + Interval::new(8320, 8334), + Interval::new(8352, 8385), + Interval::new(8448, 8485), + Interval::new(8487, 8489), + Interval::new(8492, 8497), + Interval::new(8499, 8525), + Interval::new(8527, 8543), + Interval::new(8585, 8587), + Interval::new(8592, 9257), + Interval::new(9280, 9290), + Interval::new(9312, 10239), + Interval::new(10496, 11123), + Interval::new(11126, 11263), + Interval::new(11776, 11869), + Interval::new(12272, 12292), + Interval::new(12294, 12294), + Interval::new(12296, 12320), + Interval::new(12336, 12343), + Interval::new(12348, 12351), + Interval::new(12443, 12444), + Interval::new(12448, 12448), + Interval::new(12539, 12540), + Interval::new(12688, 12703), + Interval::new(12736, 12773), + Interval::new(12783, 12783), + Interval::new(12832, 12895), + Interval::new(12927, 13007), + Interval::new(13055, 13055), + Interval::new(13144, 13311), + Interval::new(19904, 19967), + Interval::new(42752, 42785), + Interval::new(42888, 42890), + Interval::new(43056, 43065), + Interval::new(43310, 43310), + Interval::new(43471, 43471), + Interval::new(43867, 43867), + Interval::new(43882, 43883), + Interval::new(64830, 64831), + Interval::new(65040, 65049), + Interval::new(65072, 65106), + Interval::new(65108, 65126), + Interval::new(65128, 65131), + Interval::new(65279, 65279), + Interval::new(65281, 65312), + Interval::new(65339, 65344), + Interval::new(65371, 65381), + Interval::new(65392, 65392), + Interval::new(65438, 65439), + Interval::new(65504, 65510), + Interval::new(65512, 65518), + Interval::new(65529, 65533), + Interval::new(65792, 65794), + Interval::new(65799, 65843), + Interval::new(65847, 65855), + Interval::new(65936, 65948), + Interval::new(66000, 66044), + Interval::new(66273, 66299), + Interval::new(113824, 113827), + Interval::new(117760, 118012), + Interval::new(118016, 118451), + Interval::new(118458, 118480), + Interval::new(118496, 118512), + Interval::new(118608, 118723), + Interval::new(118784, 119029), + Interval::new(119040, 119078), + Interval::new(119081, 119142), + Interval::new(119146, 119162), + Interval::new(119171, 119172), + Interval::new(119180, 119209), + Interval::new(119214, 119274), + Interval::new(119488, 119507), + Interval::new(119520, 119539), + Interval::new(119552, 119638), + Interval::new(119648, 119672), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120779), + Interval::new(120782, 120831), + Interval::new(126065, 126132), + Interval::new(126209, 126269), + Interval::new(126976, 127019), + Interval::new(127024, 127123), + Interval::new(127136, 127150), + Interval::new(127153, 127167), + Interval::new(127169, 127183), + Interval::new(127185, 127221), + Interval::new(127232, 127405), + Interval::new(127462, 127487), + Interval::new(127489, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127568, 127569), + Interval::new(127584, 127589), + Interval::new(127744, 128728), + Interval::new(128732, 128748), + Interval::new(128752, 128764), + Interval::new(128768, 128985), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129024, 129035), + Interval::new(129040, 129095), + Interval::new(129104, 129113), + Interval::new(129120, 129159), + Interval::new(129168, 129197), + Interval::new(129200, 129211), + Interval::new(129216, 129217), + Interval::new(129232, 129240), + Interval::new(129280, 129623), + Interval::new(129632, 129645), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), + Interval::new(129792, 129938), + Interval::new(129940, 130042), + Interval::new(917505, 917505), + Interval::new(917536, 917631), +]; + +const COMMON_EXTENSIONS: [Interval; 161] = [ + Interval::new(0, 64), + Interval::new(91, 96), + Interval::new(123, 169), + Interval::new(171, 182), + Interval::new(184, 185), + Interval::new(187, 191), + Interval::new(215, 215), + Interval::new(247, 247), + Interval::new(697, 699), + Interval::new(701, 710), + Interval::new(712, 712), + Interval::new(716, 716), + Interval::new(718, 726), + Interval::new(728, 728), + Interval::new(730, 735), + Interval::new(741, 745), + Interval::new(748, 767), + Interval::new(894, 894), + Interval::new(901, 901), + Interval::new(903, 903), + Interval::new(1541, 1541), + Interval::new(1757, 1757), + Interval::new(2274, 2274), + Interval::new(3647, 3647), + Interval::new(4053, 4056), + Interval::new(8192, 8203), + Interval::new(8206, 8238), + Interval::new(8240, 8270), + Interval::new(8272, 8281), + Interval::new(8283, 8284), + Interval::new(8286, 8292), + Interval::new(8294, 8304), + Interval::new(8308, 8318), + Interval::new(8320, 8334), + Interval::new(8352, 8385), + Interval::new(8448, 8485), + Interval::new(8487, 8489), + Interval::new(8492, 8497), + Interval::new(8499, 8525), + Interval::new(8527, 8543), + Interval::new(8585, 8587), + Interval::new(8592, 9257), + Interval::new(9280, 9290), + Interval::new(9312, 10239), + Interval::new(10496, 11123), + Interval::new(11126, 11263), + Interval::new(11776, 11798), + Interval::new(11800, 11823), + Interval::new(11826, 11835), + Interval::new(11837, 11840), + Interval::new(11842, 11842), + Interval::new(11844, 11869), + Interval::new(12288, 12288), + Interval::new(12292, 12292), + Interval::new(12306, 12306), + Interval::new(12320, 12320), + Interval::new(12342, 12342), + Interval::new(12872, 12895), + Interval::new(12927, 12927), + Interval::new(12977, 12991), + Interval::new(13004, 13007), + Interval::new(13169, 13178), + Interval::new(13184, 13279), + Interval::new(13311, 13311), + Interval::new(19904, 19967), + Interval::new(42760, 42785), + Interval::new(42888, 42890), + Interval::new(43867, 43867), + Interval::new(43882, 43883), + Interval::new(65040, 65049), + Interval::new(65072, 65092), + Interval::new(65095, 65106), + Interval::new(65108, 65126), + Interval::new(65128, 65131), + Interval::new(65279, 65279), + Interval::new(65281, 65312), + Interval::new(65339, 65344), + Interval::new(65371, 65376), + Interval::new(65504, 65510), + Interval::new(65512, 65518), + Interval::new(65529, 65533), + Interval::new(65936, 65948), + Interval::new(66000, 66044), + Interval::new(117760, 118012), + Interval::new(118016, 118451), + Interval::new(118458, 118480), + Interval::new(118496, 118512), + Interval::new(118608, 118723), + Interval::new(118784, 119029), + Interval::new(119040, 119078), + Interval::new(119081, 119142), + Interval::new(119146, 119162), + Interval::new(119171, 119172), + Interval::new(119180, 119209), + Interval::new(119214, 119274), + Interval::new(119488, 119507), + Interval::new(119520, 119539), + Interval::new(119552, 119638), + Interval::new(119666, 119672), + Interval::new(119808, 119892), + Interval::new(119894, 119964), + Interval::new(119966, 119967), + Interval::new(119970, 119970), + Interval::new(119973, 119974), + Interval::new(119977, 119980), + Interval::new(119982, 119993), + Interval::new(119995, 119995), + Interval::new(119997, 120003), + Interval::new(120005, 120069), + Interval::new(120071, 120074), + Interval::new(120077, 120084), + Interval::new(120086, 120092), + Interval::new(120094, 120121), + Interval::new(120123, 120126), + Interval::new(120128, 120132), + Interval::new(120134, 120134), + Interval::new(120138, 120144), + Interval::new(120146, 120485), + Interval::new(120488, 120779), + Interval::new(120782, 120831), + Interval::new(126065, 126132), + Interval::new(126209, 126269), + Interval::new(126976, 127019), + Interval::new(127024, 127123), + Interval::new(127136, 127150), + Interval::new(127153, 127167), + Interval::new(127169, 127183), + Interval::new(127185, 127221), + Interval::new(127232, 127405), + Interval::new(127462, 127487), + Interval::new(127489, 127490), + Interval::new(127504, 127547), + Interval::new(127552, 127560), + Interval::new(127584, 127589), + Interval::new(127744, 128728), + Interval::new(128732, 128748), + Interval::new(128752, 128764), + Interval::new(128768, 128985), + Interval::new(128992, 129003), + Interval::new(129008, 129008), + Interval::new(129024, 129035), + Interval::new(129040, 129095), + Interval::new(129104, 129113), + Interval::new(129120, 129159), + Interval::new(129168, 129197), + Interval::new(129200, 129211), + Interval::new(129216, 129217), + Interval::new(129232, 129240), + Interval::new(129280, 129623), + Interval::new(129632, 129645), + Interval::new(129648, 129660), + Interval::new(129664, 129674), + Interval::new(129678, 129734), + Interval::new(129736, 129736), + Interval::new(129741, 129756), + Interval::new(129759, 129770), + Interval::new(129775, 129784), + Interval::new(129792, 129938), + Interval::new(129940, 130042), + Interval::new(917505, 917505), + Interval::new(917536, 917631), +]; +const UNKNOWN: [Interval; 733] = [ + Interval::new(888, 889), + Interval::new(896, 899), + Interval::new(907, 907), + Interval::new(909, 909), + Interval::new(930, 930), + Interval::new(1328, 1328), + Interval::new(1367, 1368), + Interval::new(1419, 1420), + Interval::new(1424, 1424), + Interval::new(1480, 1487), + Interval::new(1515, 1518), + Interval::new(1525, 1535), + Interval::new(1806, 1806), + Interval::new(1867, 1868), + Interval::new(1970, 1983), + Interval::new(2043, 2044), + Interval::new(2094, 2095), + Interval::new(2111, 2111), + Interval::new(2140, 2141), + Interval::new(2143, 2143), + Interval::new(2155, 2159), + Interval::new(2194, 2198), + Interval::new(2436, 2436), + Interval::new(2445, 2446), + Interval::new(2449, 2450), + Interval::new(2473, 2473), + Interval::new(2481, 2481), + Interval::new(2483, 2485), + Interval::new(2490, 2491), + Interval::new(2501, 2502), + Interval::new(2505, 2506), + Interval::new(2511, 2518), + Interval::new(2520, 2523), + Interval::new(2526, 2526), + Interval::new(2532, 2533), + Interval::new(2559, 2560), + Interval::new(2564, 2564), + Interval::new(2571, 2574), + Interval::new(2577, 2578), + Interval::new(2601, 2601), + Interval::new(2609, 2609), + Interval::new(2612, 2612), + Interval::new(2615, 2615), + Interval::new(2618, 2619), + Interval::new(2621, 2621), + Interval::new(2627, 2630), + Interval::new(2633, 2634), + Interval::new(2638, 2640), + Interval::new(2642, 2648), + Interval::new(2653, 2653), + Interval::new(2655, 2661), + Interval::new(2679, 2688), + Interval::new(2692, 2692), + Interval::new(2702, 2702), + Interval::new(2706, 2706), + Interval::new(2729, 2729), + Interval::new(2737, 2737), + Interval::new(2740, 2740), + Interval::new(2746, 2747), + Interval::new(2758, 2758), + Interval::new(2762, 2762), + Interval::new(2766, 2767), + Interval::new(2769, 2783), + Interval::new(2788, 2789), + Interval::new(2802, 2808), + Interval::new(2816, 2816), + Interval::new(2820, 2820), + Interval::new(2829, 2830), + Interval::new(2833, 2834), + Interval::new(2857, 2857), + Interval::new(2865, 2865), + Interval::new(2868, 2868), + Interval::new(2874, 2875), + Interval::new(2885, 2886), + Interval::new(2889, 2890), + Interval::new(2894, 2900), + Interval::new(2904, 2907), + Interval::new(2910, 2910), + Interval::new(2916, 2917), + Interval::new(2936, 2945), + Interval::new(2948, 2948), + Interval::new(2955, 2957), + Interval::new(2961, 2961), + Interval::new(2966, 2968), + Interval::new(2971, 2971), + Interval::new(2973, 2973), + Interval::new(2976, 2978), + Interval::new(2981, 2983), + Interval::new(2987, 2989), + Interval::new(3002, 3005), + Interval::new(3011, 3013), + Interval::new(3017, 3017), + Interval::new(3022, 3023), + Interval::new(3025, 3030), + Interval::new(3032, 3045), + Interval::new(3067, 3071), + Interval::new(3085, 3085), + Interval::new(3089, 3089), + Interval::new(3113, 3113), + Interval::new(3130, 3131), + Interval::new(3141, 3141), + Interval::new(3145, 3145), + Interval::new(3150, 3156), + Interval::new(3159, 3159), + Interval::new(3163, 3163), + Interval::new(3166, 3167), + Interval::new(3172, 3173), + Interval::new(3184, 3190), + Interval::new(3213, 3213), + Interval::new(3217, 3217), + Interval::new(3241, 3241), + Interval::new(3252, 3252), + Interval::new(3258, 3259), + Interval::new(3269, 3269), + Interval::new(3273, 3273), + Interval::new(3278, 3284), + Interval::new(3287, 3291), + Interval::new(3295, 3295), + Interval::new(3300, 3301), + Interval::new(3312, 3312), + Interval::new(3316, 3327), + Interval::new(3341, 3341), + Interval::new(3345, 3345), + Interval::new(3397, 3397), + Interval::new(3401, 3401), + Interval::new(3408, 3411), + Interval::new(3428, 3429), + Interval::new(3456, 3456), + Interval::new(3460, 3460), + Interval::new(3479, 3481), + Interval::new(3506, 3506), + Interval::new(3516, 3516), + Interval::new(3518, 3519), + Interval::new(3527, 3529), + Interval::new(3531, 3534), + Interval::new(3541, 3541), + Interval::new(3543, 3543), + Interval::new(3552, 3557), + Interval::new(3568, 3569), + Interval::new(3573, 3584), + Interval::new(3643, 3646), + Interval::new(3676, 3712), + Interval::new(3715, 3715), + Interval::new(3717, 3717), + Interval::new(3723, 3723), + Interval::new(3748, 3748), + Interval::new(3750, 3750), + Interval::new(3774, 3775), + Interval::new(3781, 3781), + Interval::new(3783, 3783), + Interval::new(3791, 3791), + Interval::new(3802, 3803), + Interval::new(3808, 3839), + Interval::new(3912, 3912), + Interval::new(3949, 3952), + Interval::new(3992, 3992), + Interval::new(4029, 4029), + Interval::new(4045, 4045), + Interval::new(4059, 4095), + Interval::new(4294, 4294), + Interval::new(4296, 4300), + Interval::new(4302, 4303), + Interval::new(4681, 4681), + Interval::new(4686, 4687), + Interval::new(4695, 4695), + Interval::new(4697, 4697), + Interval::new(4702, 4703), + Interval::new(4745, 4745), + Interval::new(4750, 4751), + Interval::new(4785, 4785), + Interval::new(4790, 4791), + Interval::new(4799, 4799), + Interval::new(4801, 4801), + Interval::new(4806, 4807), + Interval::new(4823, 4823), + Interval::new(4881, 4881), + Interval::new(4886, 4887), + Interval::new(4955, 4956), + Interval::new(4989, 4991), + Interval::new(5018, 5023), + Interval::new(5110, 5111), + Interval::new(5118, 5119), + Interval::new(5789, 5791), + Interval::new(5881, 5887), + Interval::new(5910, 5918), + Interval::new(5943, 5951), + Interval::new(5972, 5983), + Interval::new(5997, 5997), + Interval::new(6001, 6001), + Interval::new(6004, 6015), + Interval::new(6110, 6111), + Interval::new(6122, 6127), + Interval::new(6138, 6143), + Interval::new(6170, 6175), + Interval::new(6265, 6271), + Interval::new(6315, 6319), + Interval::new(6390, 6399), + Interval::new(6431, 6431), + Interval::new(6444, 6447), + Interval::new(6460, 6463), + Interval::new(6465, 6467), + Interval::new(6510, 6511), + Interval::new(6517, 6527), + Interval::new(6572, 6575), + Interval::new(6602, 6607), + Interval::new(6619, 6621), + Interval::new(6684, 6685), + Interval::new(6751, 6751), + Interval::new(6781, 6782), + Interval::new(6794, 6799), + Interval::new(6810, 6815), + Interval::new(6830, 6831), + Interval::new(6878, 6879), + Interval::new(6892, 6911), + Interval::new(6989, 6989), + Interval::new(7156, 7163), + Interval::new(7224, 7226), + Interval::new(7242, 7244), + Interval::new(7307, 7311), + Interval::new(7355, 7356), + Interval::new(7368, 7375), + Interval::new(7419, 7423), + Interval::new(7958, 7959), + Interval::new(7966, 7967), + Interval::new(8006, 8007), + Interval::new(8014, 8015), + Interval::new(8024, 8024), + Interval::new(8026, 8026), + Interval::new(8028, 8028), + Interval::new(8030, 8030), + Interval::new(8062, 8063), + Interval::new(8117, 8117), + Interval::new(8133, 8133), + Interval::new(8148, 8149), + Interval::new(8156, 8156), + Interval::new(8176, 8177), + Interval::new(8181, 8181), + Interval::new(8191, 8191), + Interval::new(8293, 8293), + Interval::new(8306, 8307), + Interval::new(8335, 8335), + Interval::new(8349, 8351), + Interval::new(8386, 8399), + Interval::new(8433, 8447), + Interval::new(8588, 8591), + Interval::new(9258, 9279), + Interval::new(9291, 9311), + Interval::new(11124, 11125), + Interval::new(11508, 11512), + Interval::new(11558, 11558), + Interval::new(11560, 11564), + Interval::new(11566, 11567), + Interval::new(11624, 11630), + Interval::new(11633, 11646), + Interval::new(11671, 11679), + Interval::new(11687, 11687), + Interval::new(11695, 11695), + Interval::new(11703, 11703), + Interval::new(11711, 11711), + Interval::new(11719, 11719), + Interval::new(11727, 11727), + Interval::new(11735, 11735), + Interval::new(11743, 11743), + Interval::new(11870, 11903), + Interval::new(11930, 11930), + Interval::new(12020, 12031), + Interval::new(12246, 12271), + Interval::new(12352, 12352), + Interval::new(12439, 12440), + Interval::new(12544, 12548), + Interval::new(12592, 12592), + Interval::new(12687, 12687), + Interval::new(12774, 12782), + Interval::new(12831, 12831), + Interval::new(42125, 42127), + Interval::new(42183, 42191), + Interval::new(42540, 42559), + Interval::new(42744, 42751), + Interval::new(42973, 42992), + Interval::new(43053, 43055), + Interval::new(43066, 43071), + Interval::new(43128, 43135), + Interval::new(43206, 43213), + Interval::new(43226, 43231), + Interval::new(43348, 43358), + Interval::new(43389, 43391), + Interval::new(43470, 43470), + Interval::new(43482, 43485), + Interval::new(43519, 43519), + Interval::new(43575, 43583), + Interval::new(43598, 43599), + Interval::new(43610, 43611), + Interval::new(43715, 43738), + Interval::new(43767, 43776), + Interval::new(43783, 43784), + Interval::new(43791, 43792), + Interval::new(43799, 43807), + Interval::new(43815, 43815), + Interval::new(43823, 43823), + Interval::new(43884, 43887), + Interval::new(44014, 44015), + Interval::new(44026, 44031), + Interval::new(55204, 55215), + Interval::new(55239, 55242), + Interval::new(55292, 63743), + Interval::new(64110, 64111), + Interval::new(64218, 64255), + Interval::new(64263, 64274), + Interval::new(64280, 64284), + Interval::new(64311, 64311), + Interval::new(64317, 64317), + Interval::new(64319, 64319), + Interval::new(64322, 64322), + Interval::new(64325, 64325), + Interval::new(64976, 65007), + Interval::new(65050, 65055), + Interval::new(65107, 65107), + Interval::new(65127, 65127), + Interval::new(65132, 65135), + Interval::new(65141, 65141), + Interval::new(65277, 65278), + Interval::new(65280, 65280), + Interval::new(65471, 65473), + Interval::new(65480, 65481), + Interval::new(65488, 65489), + Interval::new(65496, 65497), + Interval::new(65501, 65503), + Interval::new(65511, 65511), + Interval::new(65519, 65528), + Interval::new(65534, 65535), + Interval::new(65548, 65548), + Interval::new(65575, 65575), + Interval::new(65595, 65595), + Interval::new(65598, 65598), + Interval::new(65614, 65615), + Interval::new(65630, 65663), + Interval::new(65787, 65791), + Interval::new(65795, 65798), + Interval::new(65844, 65846), + Interval::new(65935, 65935), + Interval::new(65949, 65951), + Interval::new(65953, 65999), + Interval::new(66046, 66175), + Interval::new(66205, 66207), + Interval::new(66257, 66271), + Interval::new(66300, 66303), + Interval::new(66340, 66348), + Interval::new(66379, 66383), + Interval::new(66427, 66431), + Interval::new(66462, 66462), + Interval::new(66500, 66503), + Interval::new(66518, 66559), + Interval::new(66718, 66719), + Interval::new(66730, 66735), + Interval::new(66772, 66775), + Interval::new(66812, 66815), + Interval::new(66856, 66863), + Interval::new(66916, 66926), + Interval::new(66939, 66939), + Interval::new(66955, 66955), + Interval::new(66963, 66963), + Interval::new(66966, 66966), + Interval::new(66978, 66978), + Interval::new(66994, 66994), + Interval::new(67002, 67002), + Interval::new(67005, 67007), + Interval::new(67060, 67071), + Interval::new(67383, 67391), + Interval::new(67414, 67423), + Interval::new(67432, 67455), + Interval::new(67462, 67462), + Interval::new(67505, 67505), + Interval::new(67515, 67583), + Interval::new(67590, 67591), + Interval::new(67593, 67593), + Interval::new(67638, 67638), + Interval::new(67641, 67643), + Interval::new(67645, 67646), + Interval::new(67670, 67670), + Interval::new(67743, 67750), + Interval::new(67760, 67807), + Interval::new(67827, 67827), + Interval::new(67830, 67834), + Interval::new(67868, 67870), + Interval::new(67898, 67902), + Interval::new(67930, 67967), + Interval::new(68024, 68027), + Interval::new(68048, 68049), + Interval::new(68100, 68100), + Interval::new(68103, 68107), + Interval::new(68116, 68116), + Interval::new(68120, 68120), + Interval::new(68150, 68151), + Interval::new(68155, 68158), + Interval::new(68169, 68175), + Interval::new(68185, 68191), + Interval::new(68256, 68287), + Interval::new(68327, 68330), + Interval::new(68343, 68351), + Interval::new(68406, 68408), + Interval::new(68438, 68439), + Interval::new(68467, 68471), + Interval::new(68498, 68504), + Interval::new(68509, 68520), + Interval::new(68528, 68607), + Interval::new(68681, 68735), + Interval::new(68787, 68799), + Interval::new(68851, 68857), + Interval::new(68904, 68911), + Interval::new(68922, 68927), + Interval::new(68966, 68968), + Interval::new(68998, 69005), + Interval::new(69008, 69215), + Interval::new(69247, 69247), + Interval::new(69290, 69290), + Interval::new(69294, 69295), + Interval::new(69298, 69313), + Interval::new(69320, 69327), + Interval::new(69337, 69369), + Interval::new(69416, 69423), + Interval::new(69466, 69487), + Interval::new(69514, 69551), + Interval::new(69580, 69599), + Interval::new(69623, 69631), + Interval::new(69710, 69713), + Interval::new(69750, 69758), + Interval::new(69827, 69836), + Interval::new(69838, 69839), + Interval::new(69865, 69871), + Interval::new(69882, 69887), + Interval::new(69941, 69941), + Interval::new(69960, 69967), + Interval::new(70007, 70015), + Interval::new(70112, 70112), + Interval::new(70133, 70143), + Interval::new(70162, 70162), + Interval::new(70210, 70271), + Interval::new(70279, 70279), + Interval::new(70281, 70281), + Interval::new(70286, 70286), + Interval::new(70302, 70302), + Interval::new(70314, 70319), + Interval::new(70379, 70383), + Interval::new(70394, 70399), + Interval::new(70404, 70404), + Interval::new(70413, 70414), + Interval::new(70417, 70418), + Interval::new(70441, 70441), + Interval::new(70449, 70449), + Interval::new(70452, 70452), + Interval::new(70458, 70458), + Interval::new(70469, 70470), + Interval::new(70473, 70474), + Interval::new(70478, 70479), + Interval::new(70481, 70486), + Interval::new(70488, 70492), + Interval::new(70500, 70501), + Interval::new(70509, 70511), + Interval::new(70517, 70527), + Interval::new(70538, 70538), + Interval::new(70540, 70541), + Interval::new(70543, 70543), + Interval::new(70582, 70582), + Interval::new(70593, 70593), + Interval::new(70595, 70596), + Interval::new(70598, 70598), + Interval::new(70603, 70603), + Interval::new(70614, 70614), + Interval::new(70617, 70624), + Interval::new(70627, 70655), + Interval::new(70748, 70748), + Interval::new(70754, 70783), + Interval::new(70856, 70863), + Interval::new(70874, 71039), + Interval::new(71094, 71095), + Interval::new(71134, 71167), + Interval::new(71237, 71247), + Interval::new(71258, 71263), + Interval::new(71277, 71295), + Interval::new(71354, 71359), + Interval::new(71370, 71375), + Interval::new(71396, 71423), + Interval::new(71451, 71452), + Interval::new(71468, 71471), + Interval::new(71495, 71679), + Interval::new(71740, 71839), + Interval::new(71923, 71934), + Interval::new(71943, 71944), + Interval::new(71946, 71947), + Interval::new(71956, 71956), + Interval::new(71959, 71959), + Interval::new(71990, 71990), + Interval::new(71993, 71994), + Interval::new(72007, 72015), + Interval::new(72026, 72095), + Interval::new(72104, 72105), + Interval::new(72152, 72153), + Interval::new(72165, 72191), + Interval::new(72264, 72271), + Interval::new(72355, 72367), + Interval::new(72441, 72447), + Interval::new(72458, 72543), + Interval::new(72552, 72639), + Interval::new(72674, 72687), + Interval::new(72698, 72703), + Interval::new(72713, 72713), + Interval::new(72759, 72759), + Interval::new(72774, 72783), + Interval::new(72813, 72815), + Interval::new(72848, 72849), + Interval::new(72872, 72872), + Interval::new(72887, 72959), + Interval::new(72967, 72967), + Interval::new(72970, 72970), + Interval::new(73015, 73017), + Interval::new(73019, 73019), + Interval::new(73022, 73022), + Interval::new(73032, 73039), + Interval::new(73050, 73055), + Interval::new(73062, 73062), + Interval::new(73065, 73065), + Interval::new(73103, 73103), + Interval::new(73106, 73106), + Interval::new(73113, 73119), + Interval::new(73130, 73135), + Interval::new(73180, 73183), + Interval::new(73194, 73439), + Interval::new(73465, 73471), + Interval::new(73489, 73489), + Interval::new(73531, 73533), + Interval::new(73563, 73647), + Interval::new(73649, 73663), + Interval::new(73714, 73726), + Interval::new(74650, 74751), + Interval::new(74863, 74863), + Interval::new(74869, 74879), + Interval::new(75076, 77711), + Interval::new(77811, 77823), + Interval::new(78934, 78943), + Interval::new(82939, 82943), + Interval::new(83527, 90367), + Interval::new(90426, 92159), + Interval::new(92729, 92735), + Interval::new(92767, 92767), + Interval::new(92778, 92781), + Interval::new(92863, 92863), + Interval::new(92874, 92879), + Interval::new(92910, 92911), + Interval::new(92918, 92927), + Interval::new(92998, 93007), + Interval::new(93018, 93018), + Interval::new(93026, 93026), + Interval::new(93048, 93052), + Interval::new(93072, 93503), + Interval::new(93562, 93759), + Interval::new(93851, 93855), + Interval::new(93881, 93882), + Interval::new(93908, 93951), + Interval::new(94027, 94030), + Interval::new(94088, 94094), + Interval::new(94112, 94175), + Interval::new(94181, 94191), + Interval::new(94199, 94207), + Interval::new(101590, 101630), + Interval::new(101663, 101759), + Interval::new(101875, 110575), + Interval::new(110580, 110580), + Interval::new(110588, 110588), + Interval::new(110591, 110591), + Interval::new(110883, 110897), + Interval::new(110899, 110927), + Interval::new(110931, 110932), + Interval::new(110934, 110947), + Interval::new(110952, 110959), + Interval::new(111356, 113663), + Interval::new(113771, 113775), + Interval::new(113789, 113791), + Interval::new(113801, 113807), + Interval::new(113818, 113819), + Interval::new(113828, 117759), + Interval::new(118013, 118015), + Interval::new(118452, 118457), + Interval::new(118481, 118495), + Interval::new(118513, 118527), + Interval::new(118574, 118575), + Interval::new(118599, 118607), + Interval::new(118724, 118783), + Interval::new(119030, 119039), + Interval::new(119079, 119080), + Interval::new(119275, 119295), + Interval::new(119366, 119487), + Interval::new(119508, 119519), + Interval::new(119540, 119551), + Interval::new(119639, 119647), + Interval::new(119673, 119807), + Interval::new(119893, 119893), + Interval::new(119965, 119965), + Interval::new(119968, 119969), + Interval::new(119971, 119972), + Interval::new(119975, 119976), + Interval::new(119981, 119981), + Interval::new(119994, 119994), + Interval::new(119996, 119996), + Interval::new(120004, 120004), + Interval::new(120070, 120070), + Interval::new(120075, 120076), + Interval::new(120085, 120085), + Interval::new(120093, 120093), + Interval::new(120122, 120122), + Interval::new(120127, 120127), + Interval::new(120133, 120133), + Interval::new(120135, 120137), + Interval::new(120145, 120145), + Interval::new(120486, 120487), + Interval::new(120780, 120781), + Interval::new(121484, 121498), + Interval::new(121504, 121504), + Interval::new(121520, 122623), + Interval::new(122655, 122660), + Interval::new(122667, 122879), + Interval::new(122887, 122887), + Interval::new(122905, 122906), + Interval::new(122914, 122914), + Interval::new(122917, 122917), + Interval::new(122923, 122927), + Interval::new(122990, 123022), + Interval::new(123024, 123135), + Interval::new(123181, 123183), + Interval::new(123198, 123199), + Interval::new(123210, 123213), + Interval::new(123216, 123535), + Interval::new(123567, 123583), + Interval::new(123642, 123646), + Interval::new(123648, 124111), + Interval::new(124154, 124367), + Interval::new(124411, 124414), + Interval::new(124416, 124607), + Interval::new(124639, 124639), + Interval::new(124662, 124669), + Interval::new(124672, 124895), + Interval::new(124903, 124903), + Interval::new(124908, 124908), + Interval::new(124911, 124911), + Interval::new(124927, 124927), + Interval::new(125125, 125126), + Interval::new(125143, 125183), + Interval::new(125260, 125263), + Interval::new(125274, 125277), + Interval::new(125280, 126064), + Interval::new(126133, 126208), + Interval::new(126270, 126463), + Interval::new(126468, 126468), + Interval::new(126496, 126496), + Interval::new(126499, 126499), + Interval::new(126501, 126502), + Interval::new(126504, 126504), + Interval::new(126515, 126515), + Interval::new(126520, 126520), + Interval::new(126522, 126522), + Interval::new(126524, 126529), + Interval::new(126531, 126534), + Interval::new(126536, 126536), + Interval::new(126538, 126538), + Interval::new(126540, 126540), + Interval::new(126544, 126544), + Interval::new(126547, 126547), + Interval::new(126549, 126550), + Interval::new(126552, 126552), + Interval::new(126554, 126554), + Interval::new(126556, 126556), + Interval::new(126558, 126558), + Interval::new(126560, 126560), + Interval::new(126563, 126563), + Interval::new(126565, 126566), + Interval::new(126571, 126571), + Interval::new(126579, 126579), + Interval::new(126584, 126584), + Interval::new(126589, 126589), + Interval::new(126591, 126591), + Interval::new(126602, 126602), + Interval::new(126620, 126624), + Interval::new(126628, 126628), + Interval::new(126634, 126634), + Interval::new(126652, 126703), + Interval::new(126706, 126975), + Interval::new(127020, 127023), + Interval::new(127124, 127135), + Interval::new(127151, 127152), + Interval::new(127168, 127168), + Interval::new(127184, 127184), + Interval::new(127222, 127231), + Interval::new(127406, 127461), + Interval::new(127491, 127503), + Interval::new(127548, 127551), + Interval::new(127561, 127567), + Interval::new(127570, 127583), + Interval::new(127590, 127743), + Interval::new(128729, 128731), + Interval::new(128749, 128751), + Interval::new(128765, 128767), + Interval::new(128986, 128991), + Interval::new(129004, 129007), + Interval::new(129009, 129023), + Interval::new(129036, 129039), + Interval::new(129096, 129103), + Interval::new(129114, 129119), + Interval::new(129160, 129167), + Interval::new(129198, 129199), + Interval::new(129212, 129215), + Interval::new(129218, 129231), + Interval::new(129241, 129279), + Interval::new(129624, 129631), + Interval::new(129646, 129647), + Interval::new(129661, 129663), + Interval::new(129675, 129677), + Interval::new(129735, 129735), + Interval::new(129737, 129740), + Interval::new(129757, 129758), + Interval::new(129771, 129774), + Interval::new(129785, 129791), + Interval::new(129939, 129939), + Interval::new(130043, 131071), + Interval::new(173792, 173823), + Interval::new(178206, 178207), + Interval::new(183982, 183983), + Interval::new(191457, 191471), + Interval::new(192094, 194559), + Interval::new(195102, 196607), + Interval::new(201547, 201551), + Interval::new(210042, 917504), + Interval::new(917506, 917535), + Interval::new(917632, 917759), + Interval::new(918000, 1114111), +]; + +const UNKNOWN_EXTENSIONS: [Interval; 733] = [ + Interval::new(888, 889), + Interval::new(896, 899), + Interval::new(907, 907), + Interval::new(909, 909), + Interval::new(930, 930), + Interval::new(1328, 1328), + Interval::new(1367, 1368), + Interval::new(1419, 1420), + Interval::new(1424, 1424), + Interval::new(1480, 1487), + Interval::new(1515, 1518), + Interval::new(1525, 1535), + Interval::new(1806, 1806), + Interval::new(1867, 1868), + Interval::new(1970, 1983), + Interval::new(2043, 2044), + Interval::new(2094, 2095), + Interval::new(2111, 2111), + Interval::new(2140, 2141), + Interval::new(2143, 2143), + Interval::new(2155, 2159), + Interval::new(2194, 2198), + Interval::new(2436, 2436), + Interval::new(2445, 2446), + Interval::new(2449, 2450), + Interval::new(2473, 2473), + Interval::new(2481, 2481), + Interval::new(2483, 2485), + Interval::new(2490, 2491), + Interval::new(2501, 2502), + Interval::new(2505, 2506), + Interval::new(2511, 2518), + Interval::new(2520, 2523), + Interval::new(2526, 2526), + Interval::new(2532, 2533), + Interval::new(2559, 2560), + Interval::new(2564, 2564), + Interval::new(2571, 2574), + Interval::new(2577, 2578), + Interval::new(2601, 2601), + Interval::new(2609, 2609), + Interval::new(2612, 2612), + Interval::new(2615, 2615), + Interval::new(2618, 2619), + Interval::new(2621, 2621), + Interval::new(2627, 2630), + Interval::new(2633, 2634), + Interval::new(2638, 2640), + Interval::new(2642, 2648), + Interval::new(2653, 2653), + Interval::new(2655, 2661), + Interval::new(2679, 2688), + Interval::new(2692, 2692), + Interval::new(2702, 2702), + Interval::new(2706, 2706), + Interval::new(2729, 2729), + Interval::new(2737, 2737), + Interval::new(2740, 2740), + Interval::new(2746, 2747), + Interval::new(2758, 2758), + Interval::new(2762, 2762), + Interval::new(2766, 2767), + Interval::new(2769, 2783), + Interval::new(2788, 2789), + Interval::new(2802, 2808), + Interval::new(2816, 2816), + Interval::new(2820, 2820), + Interval::new(2829, 2830), + Interval::new(2833, 2834), + Interval::new(2857, 2857), + Interval::new(2865, 2865), + Interval::new(2868, 2868), + Interval::new(2874, 2875), + Interval::new(2885, 2886), + Interval::new(2889, 2890), + Interval::new(2894, 2900), + Interval::new(2904, 2907), + Interval::new(2910, 2910), + Interval::new(2916, 2917), + Interval::new(2936, 2945), + Interval::new(2948, 2948), + Interval::new(2955, 2957), + Interval::new(2961, 2961), + Interval::new(2966, 2968), + Interval::new(2971, 2971), + Interval::new(2973, 2973), + Interval::new(2976, 2978), + Interval::new(2981, 2983), + Interval::new(2987, 2989), + Interval::new(3002, 3005), + Interval::new(3011, 3013), + Interval::new(3017, 3017), + Interval::new(3022, 3023), + Interval::new(3025, 3030), + Interval::new(3032, 3045), + Interval::new(3067, 3071), + Interval::new(3085, 3085), + Interval::new(3089, 3089), + Interval::new(3113, 3113), + Interval::new(3130, 3131), + Interval::new(3141, 3141), + Interval::new(3145, 3145), + Interval::new(3150, 3156), + Interval::new(3159, 3159), + Interval::new(3163, 3163), + Interval::new(3166, 3167), + Interval::new(3172, 3173), + Interval::new(3184, 3190), + Interval::new(3213, 3213), + Interval::new(3217, 3217), + Interval::new(3241, 3241), + Interval::new(3252, 3252), + Interval::new(3258, 3259), + Interval::new(3269, 3269), + Interval::new(3273, 3273), + Interval::new(3278, 3284), + Interval::new(3287, 3291), + Interval::new(3295, 3295), + Interval::new(3300, 3301), + Interval::new(3312, 3312), + Interval::new(3316, 3327), + Interval::new(3341, 3341), + Interval::new(3345, 3345), + Interval::new(3397, 3397), + Interval::new(3401, 3401), + Interval::new(3408, 3411), + Interval::new(3428, 3429), + Interval::new(3456, 3456), + Interval::new(3460, 3460), + Interval::new(3479, 3481), + Interval::new(3506, 3506), + Interval::new(3516, 3516), + Interval::new(3518, 3519), + Interval::new(3527, 3529), + Interval::new(3531, 3534), + Interval::new(3541, 3541), + Interval::new(3543, 3543), + Interval::new(3552, 3557), + Interval::new(3568, 3569), + Interval::new(3573, 3584), + Interval::new(3643, 3646), + Interval::new(3676, 3712), + Interval::new(3715, 3715), + Interval::new(3717, 3717), + Interval::new(3723, 3723), + Interval::new(3748, 3748), + Interval::new(3750, 3750), + Interval::new(3774, 3775), + Interval::new(3781, 3781), + Interval::new(3783, 3783), + Interval::new(3791, 3791), + Interval::new(3802, 3803), + Interval::new(3808, 3839), + Interval::new(3912, 3912), + Interval::new(3949, 3952), + Interval::new(3992, 3992), + Interval::new(4029, 4029), + Interval::new(4045, 4045), + Interval::new(4059, 4095), + Interval::new(4294, 4294), + Interval::new(4296, 4300), + Interval::new(4302, 4303), + Interval::new(4681, 4681), + Interval::new(4686, 4687), + Interval::new(4695, 4695), + Interval::new(4697, 4697), + Interval::new(4702, 4703), + Interval::new(4745, 4745), + Interval::new(4750, 4751), + Interval::new(4785, 4785), + Interval::new(4790, 4791), + Interval::new(4799, 4799), + Interval::new(4801, 4801), + Interval::new(4806, 4807), + Interval::new(4823, 4823), + Interval::new(4881, 4881), + Interval::new(4886, 4887), + Interval::new(4955, 4956), + Interval::new(4989, 4991), + Interval::new(5018, 5023), + Interval::new(5110, 5111), + Interval::new(5118, 5119), + Interval::new(5789, 5791), + Interval::new(5881, 5887), + Interval::new(5910, 5918), + Interval::new(5943, 5951), + Interval::new(5972, 5983), + Interval::new(5997, 5997), + Interval::new(6001, 6001), + Interval::new(6004, 6015), + Interval::new(6110, 6111), + Interval::new(6122, 6127), + Interval::new(6138, 6143), + Interval::new(6170, 6175), + Interval::new(6265, 6271), + Interval::new(6315, 6319), + Interval::new(6390, 6399), + Interval::new(6431, 6431), + Interval::new(6444, 6447), + Interval::new(6460, 6463), + Interval::new(6465, 6467), + Interval::new(6510, 6511), + Interval::new(6517, 6527), + Interval::new(6572, 6575), + Interval::new(6602, 6607), + Interval::new(6619, 6621), + Interval::new(6684, 6685), + Interval::new(6751, 6751), + Interval::new(6781, 6782), + Interval::new(6794, 6799), + Interval::new(6810, 6815), + Interval::new(6830, 6831), + Interval::new(6878, 6879), + Interval::new(6892, 6911), + Interval::new(6989, 6989), + Interval::new(7156, 7163), + Interval::new(7224, 7226), + Interval::new(7242, 7244), + Interval::new(7307, 7311), + Interval::new(7355, 7356), + Interval::new(7368, 7375), + Interval::new(7419, 7423), + Interval::new(7958, 7959), + Interval::new(7966, 7967), + Interval::new(8006, 8007), + Interval::new(8014, 8015), + Interval::new(8024, 8024), + Interval::new(8026, 8026), + Interval::new(8028, 8028), + Interval::new(8030, 8030), + Interval::new(8062, 8063), + Interval::new(8117, 8117), + Interval::new(8133, 8133), + Interval::new(8148, 8149), + Interval::new(8156, 8156), + Interval::new(8176, 8177), + Interval::new(8181, 8181), + Interval::new(8191, 8191), + Interval::new(8293, 8293), + Interval::new(8306, 8307), + Interval::new(8335, 8335), + Interval::new(8349, 8351), + Interval::new(8386, 8399), + Interval::new(8433, 8447), + Interval::new(8588, 8591), + Interval::new(9258, 9279), + Interval::new(9291, 9311), + Interval::new(11124, 11125), + Interval::new(11508, 11512), + Interval::new(11558, 11558), + Interval::new(11560, 11564), + Interval::new(11566, 11567), + Interval::new(11624, 11630), + Interval::new(11633, 11646), + Interval::new(11671, 11679), + Interval::new(11687, 11687), + Interval::new(11695, 11695), + Interval::new(11703, 11703), + Interval::new(11711, 11711), + Interval::new(11719, 11719), + Interval::new(11727, 11727), + Interval::new(11735, 11735), + Interval::new(11743, 11743), + Interval::new(11870, 11903), + Interval::new(11930, 11930), + Interval::new(12020, 12031), + Interval::new(12246, 12271), + Interval::new(12352, 12352), + Interval::new(12439, 12440), + Interval::new(12544, 12548), + Interval::new(12592, 12592), + Interval::new(12687, 12687), + Interval::new(12774, 12782), + Interval::new(12831, 12831), + Interval::new(42125, 42127), + Interval::new(42183, 42191), + Interval::new(42540, 42559), + Interval::new(42744, 42751), + Interval::new(42973, 42992), + Interval::new(43053, 43055), + Interval::new(43066, 43071), + Interval::new(43128, 43135), + Interval::new(43206, 43213), + Interval::new(43226, 43231), + Interval::new(43348, 43358), + Interval::new(43389, 43391), + Interval::new(43470, 43470), + Interval::new(43482, 43485), + Interval::new(43519, 43519), + Interval::new(43575, 43583), + Interval::new(43598, 43599), + Interval::new(43610, 43611), + Interval::new(43715, 43738), + Interval::new(43767, 43776), + Interval::new(43783, 43784), + Interval::new(43791, 43792), + Interval::new(43799, 43807), + Interval::new(43815, 43815), + Interval::new(43823, 43823), + Interval::new(43884, 43887), + Interval::new(44014, 44015), + Interval::new(44026, 44031), + Interval::new(55204, 55215), + Interval::new(55239, 55242), + Interval::new(55292, 63743), + Interval::new(64110, 64111), + Interval::new(64218, 64255), + Interval::new(64263, 64274), + Interval::new(64280, 64284), + Interval::new(64311, 64311), + Interval::new(64317, 64317), + Interval::new(64319, 64319), + Interval::new(64322, 64322), + Interval::new(64325, 64325), + Interval::new(64976, 65007), + Interval::new(65050, 65055), + Interval::new(65107, 65107), + Interval::new(65127, 65127), + Interval::new(65132, 65135), + Interval::new(65141, 65141), + Interval::new(65277, 65278), + Interval::new(65280, 65280), + Interval::new(65471, 65473), + Interval::new(65480, 65481), + Interval::new(65488, 65489), + Interval::new(65496, 65497), + Interval::new(65501, 65503), + Interval::new(65511, 65511), + Interval::new(65519, 65528), + Interval::new(65534, 65535), + Interval::new(65548, 65548), + Interval::new(65575, 65575), + Interval::new(65595, 65595), + Interval::new(65598, 65598), + Interval::new(65614, 65615), + Interval::new(65630, 65663), + Interval::new(65787, 65791), + Interval::new(65795, 65798), + Interval::new(65844, 65846), + Interval::new(65935, 65935), + Interval::new(65949, 65951), + Interval::new(65953, 65999), + Interval::new(66046, 66175), + Interval::new(66205, 66207), + Interval::new(66257, 66271), + Interval::new(66300, 66303), + Interval::new(66340, 66348), + Interval::new(66379, 66383), + Interval::new(66427, 66431), + Interval::new(66462, 66462), + Interval::new(66500, 66503), + Interval::new(66518, 66559), + Interval::new(66718, 66719), + Interval::new(66730, 66735), + Interval::new(66772, 66775), + Interval::new(66812, 66815), + Interval::new(66856, 66863), + Interval::new(66916, 66926), + Interval::new(66939, 66939), + Interval::new(66955, 66955), + Interval::new(66963, 66963), + Interval::new(66966, 66966), + Interval::new(66978, 66978), + Interval::new(66994, 66994), + Interval::new(67002, 67002), + Interval::new(67005, 67007), + Interval::new(67060, 67071), + Interval::new(67383, 67391), + Interval::new(67414, 67423), + Interval::new(67432, 67455), + Interval::new(67462, 67462), + Interval::new(67505, 67505), + Interval::new(67515, 67583), + Interval::new(67590, 67591), + Interval::new(67593, 67593), + Interval::new(67638, 67638), + Interval::new(67641, 67643), + Interval::new(67645, 67646), + Interval::new(67670, 67670), + Interval::new(67743, 67750), + Interval::new(67760, 67807), + Interval::new(67827, 67827), + Interval::new(67830, 67834), + Interval::new(67868, 67870), + Interval::new(67898, 67902), + Interval::new(67930, 67967), + Interval::new(68024, 68027), + Interval::new(68048, 68049), + Interval::new(68100, 68100), + Interval::new(68103, 68107), + Interval::new(68116, 68116), + Interval::new(68120, 68120), + Interval::new(68150, 68151), + Interval::new(68155, 68158), + Interval::new(68169, 68175), + Interval::new(68185, 68191), + Interval::new(68256, 68287), + Interval::new(68327, 68330), + Interval::new(68343, 68351), + Interval::new(68406, 68408), + Interval::new(68438, 68439), + Interval::new(68467, 68471), + Interval::new(68498, 68504), + Interval::new(68509, 68520), + Interval::new(68528, 68607), + Interval::new(68681, 68735), + Interval::new(68787, 68799), + Interval::new(68851, 68857), + Interval::new(68904, 68911), + Interval::new(68922, 68927), + Interval::new(68966, 68968), + Interval::new(68998, 69005), + Interval::new(69008, 69215), + Interval::new(69247, 69247), + Interval::new(69290, 69290), + Interval::new(69294, 69295), + Interval::new(69298, 69313), + Interval::new(69320, 69327), + Interval::new(69337, 69369), + Interval::new(69416, 69423), + Interval::new(69466, 69487), + Interval::new(69514, 69551), + Interval::new(69580, 69599), + Interval::new(69623, 69631), + Interval::new(69710, 69713), + Interval::new(69750, 69758), + Interval::new(69827, 69836), + Interval::new(69838, 69839), + Interval::new(69865, 69871), + Interval::new(69882, 69887), + Interval::new(69941, 69941), + Interval::new(69960, 69967), + Interval::new(70007, 70015), + Interval::new(70112, 70112), + Interval::new(70133, 70143), + Interval::new(70162, 70162), + Interval::new(70210, 70271), + Interval::new(70279, 70279), + Interval::new(70281, 70281), + Interval::new(70286, 70286), + Interval::new(70302, 70302), + Interval::new(70314, 70319), + Interval::new(70379, 70383), + Interval::new(70394, 70399), + Interval::new(70404, 70404), + Interval::new(70413, 70414), + Interval::new(70417, 70418), + Interval::new(70441, 70441), + Interval::new(70449, 70449), + Interval::new(70452, 70452), + Interval::new(70458, 70458), + Interval::new(70469, 70470), + Interval::new(70473, 70474), + Interval::new(70478, 70479), + Interval::new(70481, 70486), + Interval::new(70488, 70492), + Interval::new(70500, 70501), + Interval::new(70509, 70511), + Interval::new(70517, 70527), + Interval::new(70538, 70538), + Interval::new(70540, 70541), + Interval::new(70543, 70543), + Interval::new(70582, 70582), + Interval::new(70593, 70593), + Interval::new(70595, 70596), + Interval::new(70598, 70598), + Interval::new(70603, 70603), + Interval::new(70614, 70614), + Interval::new(70617, 70624), + Interval::new(70627, 70655), + Interval::new(70748, 70748), + Interval::new(70754, 70783), + Interval::new(70856, 70863), + Interval::new(70874, 71039), + Interval::new(71094, 71095), + Interval::new(71134, 71167), + Interval::new(71237, 71247), + Interval::new(71258, 71263), + Interval::new(71277, 71295), + Interval::new(71354, 71359), + Interval::new(71370, 71375), + Interval::new(71396, 71423), + Interval::new(71451, 71452), + Interval::new(71468, 71471), + Interval::new(71495, 71679), + Interval::new(71740, 71839), + Interval::new(71923, 71934), + Interval::new(71943, 71944), + Interval::new(71946, 71947), + Interval::new(71956, 71956), + Interval::new(71959, 71959), + Interval::new(71990, 71990), + Interval::new(71993, 71994), + Interval::new(72007, 72015), + Interval::new(72026, 72095), + Interval::new(72104, 72105), + Interval::new(72152, 72153), + Interval::new(72165, 72191), + Interval::new(72264, 72271), + Interval::new(72355, 72367), + Interval::new(72441, 72447), + Interval::new(72458, 72543), + Interval::new(72552, 72639), + Interval::new(72674, 72687), + Interval::new(72698, 72703), + Interval::new(72713, 72713), + Interval::new(72759, 72759), + Interval::new(72774, 72783), + Interval::new(72813, 72815), + Interval::new(72848, 72849), + Interval::new(72872, 72872), + Interval::new(72887, 72959), + Interval::new(72967, 72967), + Interval::new(72970, 72970), + Interval::new(73015, 73017), + Interval::new(73019, 73019), + Interval::new(73022, 73022), + Interval::new(73032, 73039), + Interval::new(73050, 73055), + Interval::new(73062, 73062), + Interval::new(73065, 73065), + Interval::new(73103, 73103), + Interval::new(73106, 73106), + Interval::new(73113, 73119), + Interval::new(73130, 73135), + Interval::new(73180, 73183), + Interval::new(73194, 73439), + Interval::new(73465, 73471), + Interval::new(73489, 73489), + Interval::new(73531, 73533), + Interval::new(73563, 73647), + Interval::new(73649, 73663), + Interval::new(73714, 73726), + Interval::new(74650, 74751), + Interval::new(74863, 74863), + Interval::new(74869, 74879), + Interval::new(75076, 77711), + Interval::new(77811, 77823), + Interval::new(78934, 78943), + Interval::new(82939, 82943), + Interval::new(83527, 90367), + Interval::new(90426, 92159), + Interval::new(92729, 92735), + Interval::new(92767, 92767), + Interval::new(92778, 92781), + Interval::new(92863, 92863), + Interval::new(92874, 92879), + Interval::new(92910, 92911), + Interval::new(92918, 92927), + Interval::new(92998, 93007), + Interval::new(93018, 93018), + Interval::new(93026, 93026), + Interval::new(93048, 93052), + Interval::new(93072, 93503), + Interval::new(93562, 93759), + Interval::new(93851, 93855), + Interval::new(93881, 93882), + Interval::new(93908, 93951), + Interval::new(94027, 94030), + Interval::new(94088, 94094), + Interval::new(94112, 94175), + Interval::new(94181, 94191), + Interval::new(94199, 94207), + Interval::new(101590, 101630), + Interval::new(101663, 101759), + Interval::new(101875, 110575), + Interval::new(110580, 110580), + Interval::new(110588, 110588), + Interval::new(110591, 110591), + Interval::new(110883, 110897), + Interval::new(110899, 110927), + Interval::new(110931, 110932), + Interval::new(110934, 110947), + Interval::new(110952, 110959), + Interval::new(111356, 113663), + Interval::new(113771, 113775), + Interval::new(113789, 113791), + Interval::new(113801, 113807), + Interval::new(113818, 113819), + Interval::new(113828, 117759), + Interval::new(118013, 118015), + Interval::new(118452, 118457), + Interval::new(118481, 118495), + Interval::new(118513, 118527), + Interval::new(118574, 118575), + Interval::new(118599, 118607), + Interval::new(118724, 118783), + Interval::new(119030, 119039), + Interval::new(119079, 119080), + Interval::new(119275, 119295), + Interval::new(119366, 119487), + Interval::new(119508, 119519), + Interval::new(119540, 119551), + Interval::new(119639, 119647), + Interval::new(119673, 119807), + Interval::new(119893, 119893), + Interval::new(119965, 119965), + Interval::new(119968, 119969), + Interval::new(119971, 119972), + Interval::new(119975, 119976), + Interval::new(119981, 119981), + Interval::new(119994, 119994), + Interval::new(119996, 119996), + Interval::new(120004, 120004), + Interval::new(120070, 120070), + Interval::new(120075, 120076), + Interval::new(120085, 120085), + Interval::new(120093, 120093), + Interval::new(120122, 120122), + Interval::new(120127, 120127), + Interval::new(120133, 120133), + Interval::new(120135, 120137), + Interval::new(120145, 120145), + Interval::new(120486, 120487), + Interval::new(120780, 120781), + Interval::new(121484, 121498), + Interval::new(121504, 121504), + Interval::new(121520, 122623), + Interval::new(122655, 122660), + Interval::new(122667, 122879), + Interval::new(122887, 122887), + Interval::new(122905, 122906), + Interval::new(122914, 122914), + Interval::new(122917, 122917), + Interval::new(122923, 122927), + Interval::new(122990, 123022), + Interval::new(123024, 123135), + Interval::new(123181, 123183), + Interval::new(123198, 123199), + Interval::new(123210, 123213), + Interval::new(123216, 123535), + Interval::new(123567, 123583), + Interval::new(123642, 123646), + Interval::new(123648, 124111), + Interval::new(124154, 124367), + Interval::new(124411, 124414), + Interval::new(124416, 124607), + Interval::new(124639, 124639), + Interval::new(124662, 124669), + Interval::new(124672, 124895), + Interval::new(124903, 124903), + Interval::new(124908, 124908), + Interval::new(124911, 124911), + Interval::new(124927, 124927), + Interval::new(125125, 125126), + Interval::new(125143, 125183), + Interval::new(125260, 125263), + Interval::new(125274, 125277), + Interval::new(125280, 126064), + Interval::new(126133, 126208), + Interval::new(126270, 126463), + Interval::new(126468, 126468), + Interval::new(126496, 126496), + Interval::new(126499, 126499), + Interval::new(126501, 126502), + Interval::new(126504, 126504), + Interval::new(126515, 126515), + Interval::new(126520, 126520), + Interval::new(126522, 126522), + Interval::new(126524, 126529), + Interval::new(126531, 126534), + Interval::new(126536, 126536), + Interval::new(126538, 126538), + Interval::new(126540, 126540), + Interval::new(126544, 126544), + Interval::new(126547, 126547), + Interval::new(126549, 126550), + Interval::new(126552, 126552), + Interval::new(126554, 126554), + Interval::new(126556, 126556), + Interval::new(126558, 126558), + Interval::new(126560, 126560), + Interval::new(126563, 126563), + Interval::new(126565, 126566), + Interval::new(126571, 126571), + Interval::new(126579, 126579), + Interval::new(126584, 126584), + Interval::new(126589, 126589), + Interval::new(126591, 126591), + Interval::new(126602, 126602), + Interval::new(126620, 126624), + Interval::new(126628, 126628), + Interval::new(126634, 126634), + Interval::new(126652, 126703), + Interval::new(126706, 126975), + Interval::new(127020, 127023), + Interval::new(127124, 127135), + Interval::new(127151, 127152), + Interval::new(127168, 127168), + Interval::new(127184, 127184), + Interval::new(127222, 127231), + Interval::new(127406, 127461), + Interval::new(127491, 127503), + Interval::new(127548, 127551), + Interval::new(127561, 127567), + Interval::new(127570, 127583), + Interval::new(127590, 127743), + Interval::new(128729, 128731), + Interval::new(128749, 128751), + Interval::new(128765, 128767), + Interval::new(128986, 128991), + Interval::new(129004, 129007), + Interval::new(129009, 129023), + Interval::new(129036, 129039), + Interval::new(129096, 129103), + Interval::new(129114, 129119), + Interval::new(129160, 129167), + Interval::new(129198, 129199), + Interval::new(129212, 129215), + Interval::new(129218, 129231), + Interval::new(129241, 129279), + Interval::new(129624, 129631), + Interval::new(129646, 129647), + Interval::new(129661, 129663), + Interval::new(129675, 129677), + Interval::new(129735, 129735), + Interval::new(129737, 129740), + Interval::new(129757, 129758), + Interval::new(129771, 129774), + Interval::new(129785, 129791), + Interval::new(129939, 129939), + Interval::new(130043, 131071), + Interval::new(173792, 173823), + Interval::new(178206, 178207), + Interval::new(183982, 183983), + Interval::new(191457, 191471), + Interval::new(192094, 194559), + Interval::new(195102, 196607), + Interval::new(201547, 201551), + Interval::new(210042, 917504), + Interval::new(917506, 917535), + Interval::new(917632, 917759), + Interval::new(918000, 1114111), +]; + + +#[derive(Debug, Clone, Copy)] +pub enum UnicodePropertyValueScript { + Adlam, + CaucasianAlbanian, + Ahom, + Arabic, + ImperialAramaic, + Armenian, + Avestan, + Balinese, + Bamum, + BassaVah, + Batak, + Bengali, + BeriaErfe, + Bhaiksuki, + Bopomofo, + Brahmi, + Braille, + Buginese, + Buhid, + Chakma, + CanadianAboriginal, + Carian, + Cham, + Cherokee, + Chorasmian, + Coptic, + CyproMinoan, + Cypriot, + Cyrillic, + Devanagari, + DivesAkuru, + Dogra, + Deseret, + Duployan, + EgyptianHieroglyphs, + Elbasan, + Elymaic, + Ethiopic, + Garay, + Georgian, + Glagolitic, + GunjalaGondi, + MasaramGondi, + Gothic, + Grantha, + Greek, + Gujarati, + GurungKhema, + Gurmukhi, + Hangul, + Han, + Hanunoo, + Hatran, + Hebrew, + Hiragana, + AnatolianHieroglyphs, + PahawhHmong, + NyiakengPuachueHmong, + OldHungarian, + OldItalic, + Javanese, + KayahLi, + Katakana, + Kawi, + Kharoshthi, + Khmer, + Khojki, + KhitanSmallScript, + Kannada, + KiratRai, + Kaithi, + TaiTham, + Lao, + Latin, + Lepcha, + Limbu, + LinearA, + LinearB, + Lisu, + Lycian, + Lydian, + Mahajani, + Makasar, + Mandaic, + Manichaean, + Marchen, + Medefaidrin, + MendeKikakui, + MeroiticCursive, + MeroiticHieroglyphs, + Malayalam, + Modi, + Mongolian, + Mro, + MeeteiMayek, + Multani, + Myanmar, + NagMundari, + Nandinagari, + OldNorthArabian, + Nabataean, + Newa, + Nko, + Nushu, + Ogham, + OlChiki, + OlOnal, + OldTurkic, + Oriya, + Osage, + Osmanya, + OldUyghur, + Palmyrene, + PauCinHau, + OldPermic, + PhagsPa, + InscriptionalPahlavi, + PsalterPahlavi, + Phoenician, + Miao, + InscriptionalParthian, + Rejang, + HanifiRohingya, + Runic, + Samaritan, + OldSouthArabian, + Saurashtra, + SignWriting, + Shavian, + Sharada, + Siddham, + Sidetic, + Khudawadi, + Sinhala, + Sogdian, + OldSogdian, + SoraSompeng, + Soyombo, + Sundanese, + Sunuwar, + SylotiNagri, + Syriac, + Tagbanwa, + Takri, + TaiLe, + NewTaiLue, + Tamil, + Tangut, + TaiViet, + TaiYo, + Telugu, + Tifinagh, + Tagalog, + Thaana, + Thai, + Tibetan, + Tirhuta, + Tangsa, + Todhri, + TolongSiki, + Toto, + TuluTigalari, + Ugaritic, + Vai, + Vithkuqi, + WarangCiti, + Wancho, + OldPersian, + Cuneiform, + Yezidi, + Yi, + ZanabazarSquare, + Inherited, + Common, + Unknown, +} + +pub(crate) fn unicode_property_value_script_from_str( + s: &str, +) -> Option { + use UnicodePropertyValueScript::*; + match s { + "Adlam" | "Adlm" => Some(Adlam), + "Caucasian_Albanian" | "Aghb" => Some(CaucasianAlbanian), + "Ahom" => Some(Ahom), + "Arabic" | "Arab" => Some(Arabic), + "Imperial_Aramaic" | "Armi" => Some(ImperialAramaic), + "Armenian" | "Armn" => Some(Armenian), + "Avestan" | "Avst" => Some(Avestan), + "Balinese" | "Bali" => Some(Balinese), + "Bamum" | "Bamu" => Some(Bamum), + "Bassa_Vah" | "Bass" => Some(BassaVah), + "Batak" | "Batk" => Some(Batak), + "Bengali" | "Beng" => Some(Bengali), + "Beria_Erfe" | "Berf" => Some(BeriaErfe), + "Bhaiksuki" | "Bhks" => Some(Bhaiksuki), + "Bopomofo" | "Bopo" => Some(Bopomofo), + "Brahmi" | "Brah" => Some(Brahmi), + "Braille" | "Brai" => Some(Braille), + "Buginese" | "Bugi" => Some(Buginese), + "Buhid" | "Buhd" => Some(Buhid), + "Chakma" | "Cakm" => Some(Chakma), + "Canadian_Aboriginal" | "Cans" => Some(CanadianAboriginal), + "Carian" | "Cari" => Some(Carian), + "Cham" => Some(Cham), + "Cherokee" | "Cher" => Some(Cherokee), + "Chorasmian" | "Chrs" => Some(Chorasmian), + "Coptic" | "Copt" | "Qaac" => Some(Coptic), + "Cypro_Minoan" | "Cpmn" => Some(CyproMinoan), + "Cypriot" | "Cprt" => Some(Cypriot), + "Cyrillic" | "Cyrl" => Some(Cyrillic), + "Devanagari" | "Deva" => Some(Devanagari), + "Dives_Akuru" | "Diak" => Some(DivesAkuru), + "Dogra" | "Dogr" => Some(Dogra), + "Deseret" | "Dsrt" => Some(Deseret), + "Duployan" | "Dupl" => Some(Duployan), + "Egyptian_Hieroglyphs" | "Egyp" => Some(EgyptianHieroglyphs), + "Elbasan" | "Elba" => Some(Elbasan), + "Elymaic" | "Elym" => Some(Elymaic), + "Ethiopic" | "Ethi" => Some(Ethiopic), + "Garay" | "Gara" => Some(Garay), + "Georgian" | "Geor" => Some(Georgian), + "Glagolitic" | "Glag" => Some(Glagolitic), + "Gunjala_Gondi" | "Gong" => Some(GunjalaGondi), + "Masaram_Gondi" | "Gonm" => Some(MasaramGondi), + "Gothic" | "Goth" => Some(Gothic), + "Grantha" | "Gran" => Some(Grantha), + "Greek" | "Grek" => Some(Greek), + "Gujarati" | "Gujr" => Some(Gujarati), + "Gurung_Khema" | "Gukh" => Some(GurungKhema), + "Gurmukhi" | "Guru" => Some(Gurmukhi), + "Hangul" | "Hang" => Some(Hangul), + "Han" | "Hani" => Some(Han), + "Hanunoo" | "Hano" => Some(Hanunoo), + "Hatran" | "Hatr" => Some(Hatran), + "Hebrew" | "Hebr" => Some(Hebrew), + "Hiragana" | "Hira" => Some(Hiragana), + "Anatolian_Hieroglyphs" | "Hluw" => Some(AnatolianHieroglyphs), + "Pahawh_Hmong" | "Hmng" => Some(PahawhHmong), + "Nyiakeng_Puachue_Hmong" | "Hmnp" => Some(NyiakengPuachueHmong), + "Old_Hungarian" | "Hung" => Some(OldHungarian), + "Old_Italic" | "Ital" => Some(OldItalic), + "Javanese" | "Java" => Some(Javanese), + "Kayah_Li" | "Kali" => Some(KayahLi), + "Katakana" | "Kana" => Some(Katakana), + "Kawi" => Some(Kawi), + "Kharoshthi" | "Khar" => Some(Kharoshthi), + "Khmer" | "Khmr" => Some(Khmer), + "Khojki" | "Khoj" => Some(Khojki), + "Khitan_Small_Script" | "Kits" => Some(KhitanSmallScript), + "Kannada" | "Knda" => Some(Kannada), + "Kirat_Rai" | "Krai" => Some(KiratRai), + "Kaithi" | "Kthi" => Some(Kaithi), + "Tai_Tham" | "Lana" => Some(TaiTham), + "Lao" | "Laoo" => Some(Lao), + "Latin" | "Latn" => Some(Latin), + "Lepcha" | "Lepc" => Some(Lepcha), + "Limbu" | "Limb" => Some(Limbu), + "Linear_A" | "Lina" => Some(LinearA), + "Linear_B" | "Linb" => Some(LinearB), + "Lisu" => Some(Lisu), + "Lycian" | "Lyci" => Some(Lycian), + "Lydian" | "Lydi" => Some(Lydian), + "Mahajani" | "Mahj" => Some(Mahajani), + "Makasar" | "Maka" => Some(Makasar), + "Mandaic" | "Mand" => Some(Mandaic), + "Manichaean" | "Mani" => Some(Manichaean), + "Marchen" | "Marc" => Some(Marchen), + "Medefaidrin" | "Medf" => Some(Medefaidrin), + "Mende_Kikakui" | "Mend" => Some(MendeKikakui), + "Meroitic_Cursive" | "Merc" => Some(MeroiticCursive), + "Meroitic_Hieroglyphs" | "Mero" => Some(MeroiticHieroglyphs), + "Malayalam" | "Mlym" => Some(Malayalam), + "Modi" => Some(Modi), + "Mongolian" | "Mong" => Some(Mongolian), + "Mro" | "Mroo" => Some(Mro), + "Meetei_Mayek" | "Mtei" => Some(MeeteiMayek), + "Multani" | "Mult" => Some(Multani), + "Myanmar" | "Mymr" => Some(Myanmar), + "Nag_Mundari" | "Nagm" => Some(NagMundari), + "Nandinagari" | "Nand" => Some(Nandinagari), + "Old_North_Arabian" | "Narb" => Some(OldNorthArabian), + "Nabataean" | "Nbat" => Some(Nabataean), + "Newa" => Some(Newa), + "Nko" | "Nkoo" => Some(Nko), + "Nushu" | "Nshu" => Some(Nushu), + "Ogham" | "Ogam" => Some(Ogham), + "Ol_Chiki" | "Olck" => Some(OlChiki), + "Ol_Onal" | "Onao" => Some(OlOnal), + "Old_Turkic" | "Orkh" => Some(OldTurkic), + "Oriya" | "Orya" => Some(Oriya), + "Osage" | "Osge" => Some(Osage), + "Osmanya" | "Osma" => Some(Osmanya), + "Old_Uyghur" | "Ougr" => Some(OldUyghur), + "Palmyrene" | "Palm" => Some(Palmyrene), + "Pau_Cin_Hau" | "Pauc" => Some(PauCinHau), + "Old_Permic" | "Perm" => Some(OldPermic), + "Phags_Pa" | "Phag" => Some(PhagsPa), + "Inscriptional_Pahlavi" | "Phli" => Some(InscriptionalPahlavi), + "Psalter_Pahlavi" | "Phlp" => Some(PsalterPahlavi), + "Phoenician" | "Phnx" => Some(Phoenician), + "Miao" | "Plrd" => Some(Miao), + "Inscriptional_Parthian" | "Prti" => Some(InscriptionalParthian), + "Rejang" | "Rjng" => Some(Rejang), + "Hanifi_Rohingya" | "Rohg" => Some(HanifiRohingya), + "Runic" | "Runr" => Some(Runic), + "Samaritan" | "Samr" => Some(Samaritan), + "Old_South_Arabian" | "Sarb" => Some(OldSouthArabian), + "Saurashtra" | "Saur" => Some(Saurashtra), + "SignWriting" | "Sgnw" => Some(SignWriting), + "Shavian" | "Shaw" => Some(Shavian), + "Sharada" | "Shrd" => Some(Sharada), + "Siddham" | "Sidd" => Some(Siddham), + "Sidetic" | "Sidt" => Some(Sidetic), + "Khudawadi" | "Sind" => Some(Khudawadi), + "Sinhala" | "Sinh" => Some(Sinhala), + "Sogdian" | "Sogd" => Some(Sogdian), + "Old_Sogdian" | "Sogo" => Some(OldSogdian), + "Sora_Sompeng" | "Sora" => Some(SoraSompeng), + "Soyombo" | "Soyo" => Some(Soyombo), + "Sundanese" | "Sund" => Some(Sundanese), + "Sunuwar" | "Sunu" => Some(Sunuwar), + "Syloti_Nagri" | "Sylo" => Some(SylotiNagri), + "Syriac" | "Syrc" => Some(Syriac), + "Tagbanwa" | "Tagb" => Some(Tagbanwa), + "Takri" | "Takr" => Some(Takri), + "Tai_Le" | "Tale" => Some(TaiLe), + "New_Tai_Lue" | "Talu" => Some(NewTaiLue), + "Tamil" | "Taml" => Some(Tamil), + "Tangut" | "Tang" => Some(Tangut), + "Tai_Viet" | "Tavt" => Some(TaiViet), + "Tai_Yo" | "Tayo" => Some(TaiYo), + "Telugu" | "Telu" => Some(Telugu), + "Tifinagh" | "Tfng" => Some(Tifinagh), + "Tagalog" | "Tglg" => Some(Tagalog), + "Thaana" | "Thaa" => Some(Thaana), + "Thai" => Some(Thai), + "Tibetan" | "Tibt" => Some(Tibetan), + "Tirhuta" | "Tirh" => Some(Tirhuta), + "Tangsa" | "Tnsa" => Some(Tangsa), + "Todhri" | "Todr" => Some(Todhri), + "Tolong_Siki" | "Tols" => Some(TolongSiki), + "Toto" => Some(Toto), + "Tulu_Tigalari" | "Tutg" => Some(TuluTigalari), + "Ugaritic" | "Ugar" => Some(Ugaritic), + "Vai" | "Vaii" => Some(Vai), + "Vithkuqi" | "Vith" => Some(Vithkuqi), + "Warang_Citi" | "Wara" => Some(WarangCiti), + "Wancho" | "Wcho" => Some(Wancho), + "Old_Persian" | "Xpeo" => Some(OldPersian), + "Cuneiform" | "Xsux" => Some(Cuneiform), + "Yezidi" | "Yezi" => Some(Yezidi), + "Yi" | "Yiii" => Some(Yi), + "Zanabazar_Square" | "Zanb" => Some(ZanabazarSquare), + "Inherited" | "Zinh" | "Qaai" => Some(Inherited), + "Common" | "Zyyy" => Some(Common), + "Unknown" | "Zzzz" => Some(Unknown), + _ => None, + } +} + +pub(crate) fn script_value_ranges(value: &UnicodePropertyValueScript) -> &'static [Interval] { + use UnicodePropertyValueScript::*; + match value { + Adlam => &ADLAM, + CaucasianAlbanian => &CAUCASIAN_ALBANIAN, + Ahom => &AHOM, + Arabic => &ARABIC, + ImperialAramaic => &IMPERIAL_ARAMAIC, + Armenian => &ARMENIAN, + Avestan => &AVESTAN, + Balinese => &BALINESE, + Bamum => &BAMUM, + BassaVah => &BASSA_VAH, + Batak => &BATAK, + Bengali => &BENGALI, + BeriaErfe => &BERIA_ERFE, + Bhaiksuki => &BHAIKSUKI, + Bopomofo => &BOPOMOFO, + Brahmi => &BRAHMI, + Braille => &BRAILLE, + Buginese => &BUGINESE, + Buhid => &BUHID, + Chakma => &CHAKMA, + CanadianAboriginal => &CANADIAN_ABORIGINAL, + Carian => &CARIAN, + Cham => &CHAM, + Cherokee => &CHEROKEE, + Chorasmian => &CHORASMIAN, + Coptic => &COPTIC, + CyproMinoan => &CYPRO_MINOAN, + Cypriot => &CYPRIOT, + Cyrillic => &CYRILLIC, + Devanagari => &DEVANAGARI, + DivesAkuru => &DIVES_AKURU, + Dogra => &DOGRA, + Deseret => &DESERET, + Duployan => &DUPLOYAN, + EgyptianHieroglyphs => &EGYPTIAN_HIEROGLYPHS, + Elbasan => &ELBASAN, + Elymaic => &ELYMAIC, + Ethiopic => ÐIOPIC, + Garay => &GARAY, + Georgian => &GEORGIAN, + Glagolitic => &GLAGOLITIC, + GunjalaGondi => &GUNJALA_GONDI, + MasaramGondi => &MASARAM_GONDI, + Gothic => &GOTHIC, + Grantha => &GRANTHA, + Greek => &GREEK, + Gujarati => &GUJARATI, + GurungKhema => &GURUNG_KHEMA, + Gurmukhi => &GURMUKHI, + Hangul => &HANGUL, + Han => &HAN, + Hanunoo => &HANUNOO, + Hatran => &HATRAN, + Hebrew => &HEBREW, + Hiragana => &HIRAGANA, + AnatolianHieroglyphs => &ANATOLIAN_HIEROGLYPHS, + PahawhHmong => &PAHAWH_HMONG, + NyiakengPuachueHmong => &NYIAKENG_PUACHUE_HMONG, + OldHungarian => &OLD_HUNGARIAN, + OldItalic => &OLD_ITALIC, + Javanese => &JAVANESE, + KayahLi => &KAYAH_LI, + Katakana => &KATAKANA, + Kawi => &KAWI, + Kharoshthi => &KHAROSHTHI, + Khmer => &KHMER, + Khojki => &KHOJKI, + KhitanSmallScript => &KHITAN_SMALL_SCRIPT, + Kannada => &KANNADA, + KiratRai => &KIRAT_RAI, + Kaithi => &KAITHI, + TaiTham => &TAI_THAM, + Lao => &LAO, + Latin => &LATIN, + Lepcha => &LEPCHA, + Limbu => &LIMBU, + LinearA => &LINEAR_A, + LinearB => &LINEAR_B, + Lisu => &LISU, + Lycian => &LYCIAN, + Lydian => &LYDIAN, + Mahajani => &MAHAJANI, + Makasar => &MAKASAR, + Mandaic => &MANDAIC, + Manichaean => &MANICHAEAN, + Marchen => &MARCHEN, + Medefaidrin => &MEDEFAIDRIN, + MendeKikakui => &MENDE_KIKAKUI, + MeroiticCursive => &MEROITIC_CURSIVE, + MeroiticHieroglyphs => &MEROITIC_HIEROGLYPHS, + Malayalam => &MALAYALAM, + Modi => &MODI, + Mongolian => &MONGOLIAN, + Mro => &MRO, + MeeteiMayek => &MEETEI_MAYEK, + Multani => &MULTANI, + Myanmar => &MYANMAR, + NagMundari => &NAG_MUNDARI, + Nandinagari => &NANDINAGARI, + OldNorthArabian => &OLD_NORTH_ARABIAN, + Nabataean => &NABATAEAN, + Newa => &NEWA, + Nko => &NKO, + Nushu => &NUSHU, + Ogham => &OGHAM, + OlChiki => &OL_CHIKI, + OlOnal => &OL_ONAL, + OldTurkic => &OLD_TURKIC, + Oriya => &ORIYA, + Osage => &OSAGE, + Osmanya => &OSMANYA, + OldUyghur => &OLD_UYGHUR, + Palmyrene => &PALMYRENE, + PauCinHau => &PAU_CIN_HAU, + OldPermic => &OLD_PERMIC, + PhagsPa => &PHAGS_PA, + InscriptionalPahlavi => &INSCRIPTIONAL_PAHLAVI, + PsalterPahlavi => &PSALTER_PAHLAVI, + Phoenician => &PHOENICIAN, + Miao => &MIAO, + InscriptionalParthian => &INSCRIPTIONAL_PARTHIAN, + Rejang => &REJANG, + HanifiRohingya => &HANIFI_ROHINGYA, + Runic => &RUNIC, + Samaritan => &SAMARITAN, + OldSouthArabian => &OLD_SOUTH_ARABIAN, + Saurashtra => &SAURASHTRA, + SignWriting => &SIGNWRITING, + Shavian => &SHAVIAN, + Sharada => &SHARADA, + Siddham => &SIDDHAM, + Sidetic => &SIDETIC, + Khudawadi => &KHUDAWADI, + Sinhala => &SINHALA, + Sogdian => &SOGDIAN, + OldSogdian => &OLD_SOGDIAN, + SoraSompeng => &SORA_SOMPENG, + Soyombo => &SOYOMBO, + Sundanese => &SUNDANESE, + Sunuwar => &SUNUWAR, + SylotiNagri => &SYLOTI_NAGRI, + Syriac => &SYRIAC, + Tagbanwa => &TAGBANWA, + Takri => &TAKRI, + TaiLe => &TAI_LE, + NewTaiLue => &NEW_TAI_LUE, + Tamil => &TAMIL, + Tangut => &TANGUT, + TaiViet => &TAI_VIET, + TaiYo => &TAI_YO, + Telugu => &TELUGU, + Tifinagh => &TIFINAGH, + Tagalog => &TAGALOG, + Thaana => &THAANA, + Thai => &THAI, + Tibetan => &TIBETAN, + Tirhuta => &TIRHUTA, + Tangsa => &TANGSA, + Todhri => &TODHRI, + TolongSiki => &TOLONG_SIKI, + Toto => &TOTO, + TuluTigalari => &TULU_TIGALARI, + Ugaritic => &UGARITIC, + Vai => &VAI, + Vithkuqi => &VITHKUQI, + WarangCiti => &WARANG_CITI, + Wancho => &WANCHO, + OldPersian => &OLD_PERSIAN, + Cuneiform => &CUNEIFORM, + Yezidi => &YEZIDI, + Yi => &YI, + ZanabazarSquare => &ZANABAZAR_SQUARE, + Inherited => &INHERITED, + Common => &COMMON, + Unknown => &UNKNOWN, + } +} + +pub(crate) fn script_extensions_value_ranges( + value: &UnicodePropertyValueScript, +) -> &'static [Interval] { + use UnicodePropertyValueScript::*; + match value { + Adlam => &ADLAM_EXTENSIONS, + CaucasianAlbanian => &CAUCASIAN_ALBANIAN_EXTENSIONS, + Ahom => &AHOM, + Arabic => &ARABIC_EXTENSIONS, + ImperialAramaic => &IMPERIAL_ARAMAIC, + Armenian => &ARMENIAN_EXTENSIONS, + Avestan => &AVESTAN_EXTENSIONS, + Balinese => &BALINESE, + Bamum => &BAMUM, + BassaVah => &BASSA_VAH, + Batak => &BATAK, + Bengali => &BENGALI_EXTENSIONS, + BeriaErfe => &BERIA_ERFE, + Bhaiksuki => &BHAIKSUKI, + Bopomofo => &BOPOMOFO_EXTENSIONS, + Brahmi => &BRAHMI, + Braille => &BRAILLE, + Buginese => &BUGINESE_EXTENSIONS, + Buhid => &BUHID_EXTENSIONS, + Chakma => &CHAKMA_EXTENSIONS, + CanadianAboriginal => &CANADIAN_ABORIGINAL, + Carian => &CARIAN_EXTENSIONS, + Cham => &CHAM, + Cherokee => &CHEROKEE_EXTENSIONS, + Chorasmian => &CHORASMIAN, + Coptic => &COPTIC_EXTENSIONS, + CyproMinoan => &CYPRO_MINOAN_EXTENSIONS, + Cypriot => &CYPRIOT_EXTENSIONS, + Cyrillic => &CYRILLIC_EXTENSIONS, + Devanagari => &DEVANAGARI_EXTENSIONS, + DivesAkuru => &DIVES_AKURU, + Dogra => &DOGRA_EXTENSIONS, + Deseret => &DESERET, + Duployan => &DUPLOYAN_EXTENSIONS, + EgyptianHieroglyphs => &EGYPTIAN_HIEROGLYPHS, + Elbasan => &ELBASAN_EXTENSIONS, + Elymaic => &ELYMAIC, + Ethiopic => ÐIOPIC_EXTENSIONS, + Garay => &GARAY_EXTENSIONS, + Georgian => &GEORGIAN_EXTENSIONS, + Glagolitic => &GLAGOLITIC_EXTENSIONS, + GunjalaGondi => &GUNJALA_GONDI_EXTENSIONS, + MasaramGondi => &MASARAM_GONDI_EXTENSIONS, + Gothic => &GOTHIC_EXTENSIONS, + Grantha => &GRANTHA_EXTENSIONS, + Greek => &GREEK_EXTENSIONS, + Gujarati => &GUJARATI_EXTENSIONS, + GurungKhema => &GURUNG_KHEMA_EXTENSIONS, + Gurmukhi => &GURMUKHI_EXTENSIONS, + Hangul => &HANGUL_EXTENSIONS, + Han => &HAN_EXTENSIONS, + Hanunoo => &HANUNOO_EXTENSIONS, + Hatran => &HATRAN, + Hebrew => &HEBREW_EXTENSIONS, + Hiragana => &HIRAGANA_EXTENSIONS, + AnatolianHieroglyphs => &ANATOLIAN_HIEROGLYPHS, + PahawhHmong => &PAHAWH_HMONG, + NyiakengPuachueHmong => &NYIAKENG_PUACHUE_HMONG, + OldHungarian => &OLD_HUNGARIAN_EXTENSIONS, + OldItalic => &OLD_ITALIC, + Javanese => &JAVANESE_EXTENSIONS, + KayahLi => &KAYAH_LI_EXTENSIONS, + Katakana => &KATAKANA_EXTENSIONS, + Kawi => &KAWI, + Kharoshthi => &KHAROSHTHI, + Khmer => &KHMER, + Khojki => &KHOJKI_EXTENSIONS, + KhitanSmallScript => &KHITAN_SMALL_SCRIPT, + Kannada => &KANNADA_EXTENSIONS, + KiratRai => &KIRAT_RAI, + Kaithi => &KAITHI_EXTENSIONS, + TaiTham => &TAI_THAM, + Lao => &LAO, + Latin => &LATIN_EXTENSIONS, + Lepcha => &LEPCHA, + Limbu => &LIMBU_EXTENSIONS, + LinearA => &LINEAR_A_EXTENSIONS, + LinearB => &LINEAR_B_EXTENSIONS, + Lisu => &LISU_EXTENSIONS, + Lycian => &LYCIAN_EXTENSIONS, + Lydian => &LYDIAN_EXTENSIONS, + Mahajani => &MAHAJANI_EXTENSIONS, + Makasar => &MAKASAR, + Mandaic => &MANDAIC_EXTENSIONS, + Manichaean => &MANICHAEAN_EXTENSIONS, + Marchen => &MARCHEN, + Medefaidrin => &MEDEFAIDRIN, + MendeKikakui => &MENDE_KIKAKUI, + MeroiticCursive => &MEROITIC_CURSIVE, + MeroiticHieroglyphs => &MEROITIC_HIEROGLYPHS_EXTENSIONS, + Malayalam => &MALAYALAM_EXTENSIONS, + Modi => &MODI_EXTENSIONS, + Mongolian => &MONGOLIAN_EXTENSIONS, + Mro => &MRO, + MeeteiMayek => &MEETEI_MAYEK, + Multani => &MULTANI_EXTENSIONS, + Myanmar => &MYANMAR_EXTENSIONS, + NagMundari => &NAG_MUNDARI, + Nandinagari => &NANDINAGARI_EXTENSIONS, + OldNorthArabian => &OLD_NORTH_ARABIAN, + Nabataean => &NABATAEAN, + Newa => &NEWA_EXTENSIONS, + Nko => &NKO_EXTENSIONS, + Nushu => &NUSHU, + Ogham => &OGHAM, + OlChiki => &OL_CHIKI, + OlOnal => &OL_ONAL_EXTENSIONS, + OldTurkic => &OLD_TURKIC_EXTENSIONS, + Oriya => &ORIYA_EXTENSIONS, + Osage => &OSAGE_EXTENSIONS, + Osmanya => &OSMANYA, + OldUyghur => &OLD_UYGHUR_EXTENSIONS, + Palmyrene => &PALMYRENE, + PauCinHau => &PAU_CIN_HAU, + OldPermic => &OLD_PERMIC_EXTENSIONS, + PhagsPa => &PHAGS_PA_EXTENSIONS, + InscriptionalPahlavi => &INSCRIPTIONAL_PAHLAVI, + PsalterPahlavi => &PSALTER_PAHLAVI_EXTENSIONS, + Phoenician => &PHOENICIAN, + Miao => &MIAO, + InscriptionalParthian => &INSCRIPTIONAL_PARTHIAN, + Rejang => &REJANG, + HanifiRohingya => &HANIFI_ROHINGYA_EXTENSIONS, + Runic => &RUNIC_EXTENSIONS, + Samaritan => &SAMARITAN_EXTENSIONS, + OldSouthArabian => &OLD_SOUTH_ARABIAN, + Saurashtra => &SAURASHTRA, + SignWriting => &SIGNWRITING, + Shavian => &SHAVIAN_EXTENSIONS, + Sharada => &SHARADA_EXTENSIONS, + Siddham => &SIDDHAM, + Sidetic => &SIDETIC, + Khudawadi => &KHUDAWADI_EXTENSIONS, + Sinhala => &SINHALA_EXTENSIONS, + Sogdian => &SOGDIAN_EXTENSIONS, + OldSogdian => &OLD_SOGDIAN, + SoraSompeng => &SORA_SOMPENG, + Soyombo => &SOYOMBO, + Sundanese => &SUNDANESE, + Sunuwar => &SUNUWAR_EXTENSIONS, + SylotiNagri => &SYLOTI_NAGRI_EXTENSIONS, + Syriac => &SYRIAC_EXTENSIONS, + Tagbanwa => &TAGBANWA_EXTENSIONS, + Takri => &TAKRI_EXTENSIONS, + TaiLe => &TAI_LE_EXTENSIONS, + NewTaiLue => &NEW_TAI_LUE, + Tamil => &TAMIL_EXTENSIONS, + Tangut => &TANGUT_EXTENSIONS, + TaiViet => &TAI_VIET, + TaiYo => &TAI_YO, + Telugu => &TELUGU_EXTENSIONS, + Tifinagh => &TIFINAGH_EXTENSIONS, + Tagalog => &TAGALOG_EXTENSIONS, + Thaana => &THAANA_EXTENSIONS, + Thai => &THAI_EXTENSIONS, + Tibetan => &TIBETAN_EXTENSIONS, + Tirhuta => &TIRHUTA_EXTENSIONS, + Tangsa => &TANGSA, + Todhri => &TODHRI_EXTENSIONS, + TolongSiki => &TOLONG_SIKI, + Toto => &TOTO_EXTENSIONS, + TuluTigalari => &TULU_TIGALARI_EXTENSIONS, + Ugaritic => &UGARITIC, + Vai => &VAI, + Vithkuqi => &VITHKUQI, + WarangCiti => &WARANG_CITI, + Wancho => &WANCHO, + OldPersian => &OLD_PERSIAN, + Cuneiform => &CUNEIFORM, + Yezidi => &YEZIDI_EXTENSIONS, + Yi => &YI_EXTENSIONS, + ZanabazarSquare => &ZANABAZAR_SQUARE, + Inherited => &INHERITED_EXTENSIONS, + Common => &COMMON_EXTENSIONS, + Unknown => &UNKNOWN_EXTENSIONS, + } +} + +pub(crate) const TO_UPPERCASE: [FoldRange; 202] = [ + FoldRange::from(0x61, 26, -32, 1), + FoldRange::from(0xB5, 1, 743, 1), + FoldRange::from(0xE0, 23, -32, 1), + FoldRange::from(0xF8, 7, -32, 1), + FoldRange::from(0xFF, 1, 121, 1), + FoldRange::from(0x101, 47, -1, 2), + FoldRange::from(0x131, 1, -232, 1), + FoldRange::from(0x133, 5, -1, 2), + FoldRange::from(0x13A, 15, -1, 2), + FoldRange::from(0x14B, 45, -1, 2), + FoldRange::from(0x17A, 5, -1, 2), + FoldRange::from(0x17F, 1, -300, 1), + FoldRange::from(0x180, 1, 195, 1), + FoldRange::from(0x183, 3, -1, 2), + FoldRange::from(0x188, 5, -1, 4), + FoldRange::from(0x192, 1, -1, 1), + FoldRange::from(0x195, 1, 97, 1), + FoldRange::from(0x199, 1, -1, 1), + FoldRange::from(0x19A, 1, 163, 1), + FoldRange::from(0x19B, 1, 42561, 1), + FoldRange::from(0x19E, 1, 130, 1), + FoldRange::from(0x1A1, 5, -1, 2), + FoldRange::from(0x1A8, 1, -1, 1), + FoldRange::from(0x1AD, 1, -1, 1), + FoldRange::from(0x1B0, 5, -1, 4), + FoldRange::from(0x1B6, 1, -1, 1), + FoldRange::from(0x1B9, 5, -1, 4), + FoldRange::from(0x1BF, 1, 56, 1), + FoldRange::from(0x1C5, 1, -1, 1), + FoldRange::from(0x1C6, 1, -2, 1), + FoldRange::from(0x1C8, 1, -1, 1), + FoldRange::from(0x1C9, 1, -2, 1), + FoldRange::from(0x1CB, 1, -1, 1), + FoldRange::from(0x1CC, 1, -2, 1), + FoldRange::from(0x1CE, 15, -1, 2), + FoldRange::from(0x1DD, 1, -79, 1), + FoldRange::from(0x1DF, 17, -1, 2), + FoldRange::from(0x1F2, 1, -1, 1), + FoldRange::from(0x1F3, 1, -2, 1), + FoldRange::from(0x1F5, 5, -1, 4), + FoldRange::from(0x1FB, 37, -1, 2), + FoldRange::from(0x223, 17, -1, 2), + FoldRange::from(0x23C, 1, -1, 1), + FoldRange::from(0x23F, 2, 10815, 1), + FoldRange::from(0x242, 1, -1, 1), + FoldRange::from(0x247, 9, -1, 2), + FoldRange::from(0x250, 1, 10783, 1), + FoldRange::from(0x251, 1, 10780, 1), + FoldRange::from(0x252, 1, 10782, 1), + FoldRange::from(0x253, 1, -210, 1), + FoldRange::from(0x254, 1, -206, 1), + FoldRange::from(0x256, 2, -205, 1), + FoldRange::from(0x259, 1, -202, 1), + FoldRange::from(0x25B, 1, -203, 1), + FoldRange::from(0x25C, 1, 42319, 1), + FoldRange::from(0x260, 1, -205, 1), + FoldRange::from(0x261, 1, 42315, 1), + FoldRange::from(0x263, 1, -207, 1), + FoldRange::from(0x264, 1, 42343, 1), + FoldRange::from(0x265, 1, 42280, 1), + FoldRange::from(0x266, 1, 42308, 1), + FoldRange::from(0x268, 1, -209, 1), + FoldRange::from(0x269, 1, -211, 1), + FoldRange::from(0x26A, 1, 42308, 1), + FoldRange::from(0x26B, 1, 10743, 1), + FoldRange::from(0x26C, 1, 42305, 1), + FoldRange::from(0x26F, 1, -211, 1), + FoldRange::from(0x271, 1, 10749, 1), + FoldRange::from(0x272, 1, -213, 1), + FoldRange::from(0x275, 1, -214, 1), + FoldRange::from(0x27D, 1, 10727, 1), + FoldRange::from(0x280, 1, -218, 1), + FoldRange::from(0x282, 1, 42307, 1), + FoldRange::from(0x283, 1, -218, 1), + FoldRange::from(0x287, 1, 42282, 1), + FoldRange::from(0x288, 1, -218, 1), + FoldRange::from(0x289, 1, -69, 1), + FoldRange::from(0x28A, 2, -217, 1), + FoldRange::from(0x28C, 1, -71, 1), + FoldRange::from(0x292, 1, -219, 1), + FoldRange::from(0x29D, 1, 42261, 1), + FoldRange::from(0x29E, 1, 42258, 1), + FoldRange::from(0x345, 1, 84, 1), + FoldRange::from(0x371, 3, -1, 2), + FoldRange::from(0x377, 1, -1, 1), + FoldRange::from(0x37B, 3, 130, 1), + FoldRange::from(0x3AC, 1, -38, 1), + FoldRange::from(0x3AD, 3, -37, 1), + FoldRange::from(0x3B1, 17, -32, 1), + FoldRange::from(0x3C2, 1, -31, 1), + FoldRange::from(0x3C3, 9, -32, 1), + FoldRange::from(0x3CC, 1, -64, 1), + FoldRange::from(0x3CD, 2, -63, 1), + FoldRange::from(0x3D0, 1, -62, 1), + FoldRange::from(0x3D1, 1, -57, 1), + FoldRange::from(0x3D5, 1, -47, 1), + FoldRange::from(0x3D6, 1, -54, 1), + FoldRange::from(0x3D7, 1, -8, 1), + FoldRange::from(0x3D9, 23, -1, 2), + FoldRange::from(0x3F0, 1, -86, 1), + FoldRange::from(0x3F1, 1, -80, 1), + FoldRange::from(0x3F2, 1, 7, 1), + FoldRange::from(0x3F3, 1, -116, 1), + FoldRange::from(0x3F5, 1, -96, 1), + FoldRange::from(0x3F8, 1, -1, 1), + FoldRange::from(0x3FB, 1, -1, 1), + FoldRange::from(0x430, 32, -32, 1), + FoldRange::from(0x450, 16, -80, 1), + FoldRange::from(0x461, 33, -1, 2), + FoldRange::from(0x48B, 53, -1, 2), + FoldRange::from(0x4C2, 13, -1, 2), + FoldRange::from(0x4CF, 1, -15, 1), + FoldRange::from(0x4D1, 95, -1, 2), + FoldRange::from(0x561, 38, -48, 1), + FoldRange::from(0x10D0, 43, 3008, 1), + FoldRange::from(0x10FD, 3, 3008, 1), + FoldRange::from(0x13F8, 6, -8, 1), + FoldRange::from(0x1C80, 1, -6254, 1), + FoldRange::from(0x1C81, 1, -6253, 1), + FoldRange::from(0x1C82, 1, -6244, 1), + FoldRange::from(0x1C83, 2, -6242, 1), + FoldRange::from(0x1C85, 1, -6243, 1), + FoldRange::from(0x1C86, 1, -6236, 1), + FoldRange::from(0x1C87, 1, -6181, 1), + FoldRange::from(0x1C88, 1, 35266, 1), + FoldRange::from(0x1C8A, 1, -1, 1), + FoldRange::from(0x1D79, 1, 35332, 1), + FoldRange::from(0x1D7D, 1, 3814, 1), + FoldRange::from(0x1D8E, 1, 35384, 1), + FoldRange::from(0x1E01, 149, -1, 2), + FoldRange::from(0x1E9B, 1, -59, 1), + FoldRange::from(0x1EA1, 95, -1, 2), + FoldRange::from(0x1F00, 8, 8, 1), + FoldRange::from(0x1F10, 6, 8, 1), + FoldRange::from(0x1F20, 8, 8, 1), + FoldRange::from(0x1F30, 8, 8, 1), + FoldRange::from(0x1F40, 6, 8, 1), + FoldRange::from(0x1F51, 7, 8, 2), + FoldRange::from(0x1F60, 8, 8, 1), + FoldRange::from(0x1F70, 2, 74, 1), + FoldRange::from(0x1F72, 4, 86, 1), + FoldRange::from(0x1F76, 2, 100, 1), + FoldRange::from(0x1F78, 2, 128, 1), + FoldRange::from(0x1F7A, 2, 112, 1), + FoldRange::from(0x1F7C, 2, 126, 1), + FoldRange::from(0x1F80, 8, 8, 1), + FoldRange::from(0x1F90, 8, 8, 1), + FoldRange::from(0x1FA0, 8, 8, 1), + FoldRange::from(0x1FB0, 2, 8, 1), + FoldRange::from(0x1FB3, 1, 9, 1), + FoldRange::from(0x1FBE, 1, -7205, 1), + FoldRange::from(0x1FC3, 1, 9, 1), + FoldRange::from(0x1FD0, 2, 8, 1), + FoldRange::from(0x1FE0, 2, 8, 1), + FoldRange::from(0x1FE5, 1, 7, 1), + FoldRange::from(0x1FF3, 1, 9, 1), + FoldRange::from(0x214E, 1, -28, 1), + FoldRange::from(0x2170, 16, -16, 1), + FoldRange::from(0x2184, 1, -1, 1), + FoldRange::from(0x24D0, 26, -26, 1), + FoldRange::from(0x2C30, 48, -48, 1), + FoldRange::from(0x2C61, 1, -1, 1), + FoldRange::from(0x2C65, 1, -10795, 1), + FoldRange::from(0x2C66, 1, -10792, 1), + FoldRange::from(0x2C68, 5, -1, 2), + FoldRange::from(0x2C73, 1, -1, 1), + FoldRange::from(0x2C76, 1, -1, 1), + FoldRange::from(0x2C81, 99, -1, 2), + FoldRange::from(0x2CEC, 3, -1, 2), + FoldRange::from(0x2CF3, 1, -1, 1), + FoldRange::from(0x2D00, 38, -7264, 1), + FoldRange::from(0x2D27, 1, -7264, 1), + FoldRange::from(0x2D2D, 1, -7264, 1), + FoldRange::from(0xA641, 45, -1, 2), + FoldRange::from(0xA681, 27, -1, 2), + FoldRange::from(0xA723, 13, -1, 2), + FoldRange::from(0xA733, 61, -1, 2), + FoldRange::from(0xA77A, 3, -1, 2), + FoldRange::from(0xA77F, 9, -1, 2), + FoldRange::from(0xA78C, 1, -1, 1), + FoldRange::from(0xA791, 3, -1, 2), + FoldRange::from(0xA794, 1, 48, 1), + FoldRange::from(0xA797, 19, -1, 2), + FoldRange::from(0xA7B5, 15, -1, 2), + FoldRange::from(0xA7C8, 3, -1, 2), + FoldRange::from(0xA7CD, 15, -1, 2), + FoldRange::from(0xA7F6, 1, -1, 1), + FoldRange::from(0xAB53, 1, -928, 1), + FoldRange::from(0xAB70, 80, -38864, 1), + FoldRange::from(0xFF41, 26, -32, 1), + FoldRange::from(0x10428, 40, -40, 1), + FoldRange::from(0x104D8, 36, -40, 1), + FoldRange::from(0x10597, 11, -39, 1), + FoldRange::from(0x105A3, 15, -39, 1), + FoldRange::from(0x105B3, 7, -39, 1), + FoldRange::from(0x105BB, 2, -39, 1), + FoldRange::from(0x10CC0, 51, -64, 1), + FoldRange::from(0x10D70, 22, -32, 1), + FoldRange::from(0x118C0, 32, -32, 1), + FoldRange::from(0x16E60, 32, -32, 1), + FoldRange::from(0x16EBB, 25, -27, 1), + FoldRange::from(0x1E922, 34, -34, 1), +]; + +static BASIC_EMOJI: &[&[u32]; 1400] = &[ + &[8986], + &[8987], + &[9193], + &[9194], + &[9195], + &[9196], + &[9200], + &[9203], + &[9725], + &[9726], + &[9748], + &[9749], + &[9800], + &[9801], + &[9802], + &[9803], + &[9804], + &[9805], + &[9806], + &[9807], + &[9808], + &[9809], + &[9810], + &[9811], + &[9855], + &[9875], + &[9889], + &[9898], + &[9899], + &[9917], + &[9918], + &[9924], + &[9925], + &[9934], + &[9940], + &[9962], + &[9970], + &[9971], + &[9973], + &[9978], + &[9981], + &[9989], + &[9994], + &[9995], + &[10024], + &[10060], + &[10062], + &[10067], + &[10068], + &[10069], + &[10071], + &[10133], + &[10134], + &[10135], + &[10160], + &[10175], + &[11035], + &[11036], + &[11088], + &[11093], + &[126980], + &[127183], + &[127374], + &[127377], + &[127378], + &[127379], + &[127380], + &[127381], + &[127382], + &[127383], + &[127384], + &[127385], + &[127386], + &[127489], + &[127514], + &[127535], + &[127538], + &[127539], + &[127540], + &[127541], + &[127542], + &[127544], + &[127545], + &[127546], + &[127568], + &[127569], + &[127744], + &[127745], + &[127746], + &[127747], + &[127748], + &[127749], + &[127750], + &[127751], + &[127752], + &[127753], + &[127754], + &[127755], + &[127756], + &[127757], + &[127758], + &[127759], + &[127760], + &[127761], + &[127762], + &[127763], + &[127764], + &[127765], + &[127766], + &[127767], + &[127768], + &[127769], + &[127770], + &[127771], + &[127772], + &[127773], + &[127774], + &[127775], + &[127776], + &[127789], + &[127790], + &[127791], + &[127792], + &[127793], + &[127794], + &[127795], + &[127796], + &[127797], + &[127799], + &[127800], + &[127801], + &[127802], + &[127803], + &[127804], + &[127805], + &[127806], + &[127807], + &[127808], + &[127809], + &[127810], + &[127811], + &[127812], + &[127813], + &[127814], + &[127815], + &[127816], + &[127817], + &[127818], + &[127819], + &[127820], + &[127821], + &[127822], + &[127823], + &[127824], + &[127825], + &[127826], + &[127827], + &[127828], + &[127829], + &[127830], + &[127831], + &[127832], + &[127833], + &[127834], + &[127835], + &[127836], + &[127837], + &[127838], + &[127839], + &[127840], + &[127841], + &[127842], + &[127843], + &[127844], + &[127845], + &[127846], + &[127847], + &[127848], + &[127849], + &[127850], + &[127851], + &[127852], + &[127853], + &[127854], + &[127855], + &[127856], + &[127857], + &[127858], + &[127859], + &[127860], + &[127861], + &[127862], + &[127863], + &[127864], + &[127865], + &[127866], + &[127867], + &[127868], + &[127870], + &[127871], + &[127872], + &[127873], + &[127874], + &[127875], + &[127876], + &[127877], + &[127878], + &[127879], + &[127880], + &[127881], + &[127882], + &[127883], + &[127884], + &[127885], + &[127886], + &[127887], + &[127888], + &[127889], + &[127890], + &[127891], + &[127904], + &[127905], + &[127906], + &[127907], + &[127908], + &[127909], + &[127910], + &[127911], + &[127912], + &[127913], + &[127914], + &[127915], + &[127916], + &[127917], + &[127918], + &[127919], + &[127920], + &[127921], + &[127922], + &[127923], + &[127924], + &[127925], + &[127926], + &[127927], + &[127928], + &[127929], + &[127930], + &[127931], + &[127932], + &[127933], + &[127934], + &[127935], + &[127936], + &[127937], + &[127938], + &[127939], + &[127940], + &[127941], + &[127942], + &[127943], + &[127944], + &[127945], + &[127946], + &[127951], + &[127952], + &[127953], + &[127954], + &[127955], + &[127968], + &[127969], + &[127970], + &[127971], + &[127972], + &[127973], + &[127974], + &[127975], + &[127976], + &[127977], + &[127978], + &[127979], + &[127980], + &[127981], + &[127982], + &[127983], + &[127984], + &[127988], + &[127992], + &[127993], + &[127994], + &[127995], + &[127996], + &[127997], + &[127998], + &[127999], + &[128000], + &[128001], + &[128002], + &[128003], + &[128004], + &[128005], + &[128006], + &[128007], + &[128008], + &[128009], + &[128010], + &[128011], + &[128012], + &[128013], + &[128014], + &[128015], + &[128016], + &[128017], + &[128018], + &[128019], + &[128020], + &[128021], + &[128022], + &[128023], + &[128024], + &[128025], + &[128026], + &[128027], + &[128028], + &[128029], + &[128030], + &[128031], + &[128032], + &[128033], + &[128034], + &[128035], + &[128036], + &[128037], + &[128038], + &[128039], + &[128040], + &[128041], + &[128042], + &[128043], + &[128044], + &[128045], + &[128046], + &[128047], + &[128048], + &[128049], + &[128050], + &[128051], + &[128052], + &[128053], + &[128054], + &[128055], + &[128056], + &[128057], + &[128058], + &[128059], + &[128060], + &[128061], + &[128062], + &[128064], + &[128066], + &[128067], + &[128068], + &[128069], + &[128070], + &[128071], + &[128072], + &[128073], + &[128074], + &[128075], + &[128076], + &[128077], + &[128078], + &[128079], + &[128080], + &[128081], + &[128082], + &[128083], + &[128084], + &[128085], + &[128086], + &[128087], + &[128088], + &[128089], + &[128090], + &[128091], + &[128092], + &[128093], + &[128094], + &[128095], + &[128096], + &[128097], + &[128098], + &[128099], + &[128100], + &[128101], + &[128102], + &[128103], + &[128104], + &[128105], + &[128106], + &[128107], + &[128108], + &[128109], + &[128110], + &[128111], + &[128112], + &[128113], + &[128114], + &[128115], + &[128116], + &[128117], + &[128118], + &[128119], + &[128120], + &[128121], + &[128122], + &[128123], + &[128124], + &[128125], + &[128126], + &[128127], + &[128128], + &[128129], + &[128130], + &[128131], + &[128132], + &[128133], + &[128134], + &[128135], + &[128136], + &[128137], + &[128138], + &[128139], + &[128140], + &[128141], + &[128142], + &[128143], + &[128144], + &[128145], + &[128146], + &[128147], + &[128148], + &[128149], + &[128150], + &[128151], + &[128152], + &[128153], + &[128154], + &[128155], + &[128156], + &[128157], + &[128158], + &[128159], + &[128160], + &[128161], + &[128162], + &[128163], + &[128164], + &[128165], + &[128166], + &[128167], + &[128168], + &[128169], + &[128170], + &[128171], + &[128172], + &[128173], + &[128174], + &[128175], + &[128176], + &[128177], + &[128178], + &[128179], + &[128180], + &[128181], + &[128182], + &[128183], + &[128184], + &[128185], + &[128186], + &[128187], + &[128188], + &[128189], + &[128190], + &[128191], + &[128192], + &[128193], + &[128194], + &[128195], + &[128196], + &[128197], + &[128198], + &[128199], + &[128200], + &[128201], + &[128202], + &[128203], + &[128204], + &[128205], + &[128206], + &[128207], + &[128208], + &[128209], + &[128210], + &[128211], + &[128212], + &[128213], + &[128214], + &[128215], + &[128216], + &[128217], + &[128218], + &[128219], + &[128220], + &[128221], + &[128222], + &[128223], + &[128224], + &[128225], + &[128226], + &[128227], + &[128228], + &[128229], + &[128230], + &[128231], + &[128232], + &[128233], + &[128234], + &[128235], + &[128236], + &[128237], + &[128238], + &[128239], + &[128240], + &[128241], + &[128242], + &[128243], + &[128244], + &[128245], + &[128246], + &[128247], + &[128248], + &[128249], + &[128250], + &[128251], + &[128252], + &[128255], + &[128256], + &[128257], + &[128258], + &[128259], + &[128260], + &[128261], + &[128262], + &[128263], + &[128264], + &[128265], + &[128266], + &[128267], + &[128268], + &[128269], + &[128270], + &[128271], + &[128272], + &[128273], + &[128274], + &[128275], + &[128276], + &[128277], + &[128278], + &[128279], + &[128280], + &[128281], + &[128282], + &[128283], + &[128284], + &[128285], + &[128286], + &[128287], + &[128288], + &[128289], + &[128290], + &[128291], + &[128292], + &[128293], + &[128294], + &[128295], + &[128296], + &[128297], + &[128298], + &[128299], + &[128300], + &[128301], + &[128302], + &[128303], + &[128304], + &[128305], + &[128306], + &[128307], + &[128308], + &[128309], + &[128310], + &[128311], + &[128312], + &[128313], + &[128314], + &[128315], + &[128316], + &[128317], + &[128331], + &[128332], + &[128333], + &[128334], + &[128336], + &[128337], + &[128338], + &[128339], + &[128340], + &[128341], + &[128342], + &[128343], + &[128344], + &[128345], + &[128346], + &[128347], + &[128348], + &[128349], + &[128350], + &[128351], + &[128352], + &[128353], + &[128354], + &[128355], + &[128356], + &[128357], + &[128358], + &[128359], + &[128378], + &[128405], + &[128406], + &[128420], + &[128507], + &[128508], + &[128509], + &[128510], + &[128511], + &[128512], + &[128513], + &[128514], + &[128515], + &[128516], + &[128517], + &[128518], + &[128519], + &[128520], + &[128521], + &[128522], + &[128523], + &[128524], + &[128525], + &[128526], + &[128527], + &[128528], + &[128529], + &[128530], + &[128531], + &[128532], + &[128533], + &[128534], + &[128535], + &[128536], + &[128537], + &[128538], + &[128539], + &[128540], + &[128541], + &[128542], + &[128543], + &[128544], + &[128545], + &[128546], + &[128547], + &[128548], + &[128549], + &[128550], + &[128551], + &[128552], + &[128553], + &[128554], + &[128555], + &[128556], + &[128557], + &[128558], + &[128559], + &[128560], + &[128561], + &[128562], + &[128563], + &[128564], + &[128565], + &[128566], + &[128567], + &[128568], + &[128569], + &[128570], + &[128571], + &[128572], + &[128573], + &[128574], + &[128575], + &[128576], + &[128577], + &[128578], + &[128579], + &[128580], + &[128581], + &[128582], + &[128583], + &[128584], + &[128585], + &[128586], + &[128587], + &[128588], + &[128589], + &[128590], + &[128591], + &[128640], + &[128641], + &[128642], + &[128643], + &[128644], + &[128645], + &[128646], + &[128647], + &[128648], + &[128649], + &[128650], + &[128651], + &[128652], + &[128653], + &[128654], + &[128655], + &[128656], + &[128657], + &[128658], + &[128659], + &[128660], + &[128661], + &[128662], + &[128663], + &[128664], + &[128665], + &[128666], + &[128667], + &[128668], + &[128669], + &[128670], + &[128671], + &[128672], + &[128673], + &[128674], + &[128675], + &[128676], + &[128677], + &[128678], + &[128679], + &[128680], + &[128681], + &[128682], + &[128683], + &[128684], + &[128685], + &[128686], + &[128687], + &[128688], + &[128689], + &[128690], + &[128691], + &[128692], + &[128693], + &[128694], + &[128695], + &[128696], + &[128697], + &[128698], + &[128699], + &[128700], + &[128701], + &[128702], + &[128703], + &[128704], + &[128705], + &[128706], + &[128707], + &[128708], + &[128709], + &[128716], + &[128720], + &[128721], + &[128722], + &[128725], + &[128726], + &[128727], + &[128728], + &[128732], + &[128733], + &[128734], + &[128735], + &[128747], + &[128748], + &[128756], + &[128757], + &[128758], + &[128759], + &[128760], + &[128761], + &[128762], + &[128763], + &[128764], + &[128992], + &[128993], + &[128994], + &[128995], + &[128996], + &[128997], + &[128998], + &[128999], + &[129000], + &[129001], + &[129002], + &[129003], + &[129008], + &[129292], + &[129293], + &[129294], + &[129295], + &[129296], + &[129297], + &[129298], + &[129299], + &[129300], + &[129301], + &[129302], + &[129303], + &[129304], + &[129305], + &[129306], + &[129307], + &[129308], + &[129309], + &[129310], + &[129311], + &[129312], + &[129313], + &[129314], + &[129315], + &[129316], + &[129317], + &[129318], + &[129319], + &[129320], + &[129321], + &[129322], + &[129323], + &[129324], + &[129325], + &[129326], + &[129327], + &[129328], + &[129329], + &[129330], + &[129331], + &[129332], + &[129333], + &[129334], + &[129335], + &[129336], + &[129337], + &[129338], + &[129340], + &[129341], + &[129342], + &[129343], + &[129344], + &[129345], + &[129346], + &[129347], + &[129348], + &[129349], + &[129351], + &[129352], + &[129353], + &[129354], + &[129355], + &[129356], + &[129357], + &[129358], + &[129359], + &[129360], + &[129361], + &[129362], + &[129363], + &[129364], + &[129365], + &[129366], + &[129367], + &[129368], + &[129369], + &[129370], + &[129371], + &[129372], + &[129373], + &[129374], + &[129375], + &[129376], + &[129377], + &[129378], + &[129379], + &[129380], + &[129381], + &[129382], + &[129383], + &[129384], + &[129385], + &[129386], + &[129387], + &[129388], + &[129389], + &[129390], + &[129391], + &[129392], + &[129393], + &[129394], + &[129395], + &[129396], + &[129397], + &[129398], + &[129399], + &[129400], + &[129401], + &[129402], + &[129403], + &[129404], + &[129405], + &[129406], + &[129407], + &[129408], + &[129409], + &[129410], + &[129411], + &[129412], + &[129413], + &[129414], + &[129415], + &[129416], + &[129417], + &[129418], + &[129419], + &[129420], + &[129421], + &[129422], + &[129423], + &[129424], + &[129425], + &[129426], + &[129427], + &[129428], + &[129429], + &[129430], + &[129431], + &[129432], + &[129433], + &[129434], + &[129435], + &[129436], + &[129437], + &[129438], + &[129439], + &[129440], + &[129441], + &[129442], + &[129443], + &[129444], + &[129445], + &[129446], + &[129447], + &[129448], + &[129449], + &[129450], + &[129451], + &[129452], + &[129453], + &[129454], + &[129455], + &[129456], + &[129457], + &[129458], + &[129459], + &[129460], + &[129461], + &[129462], + &[129463], + &[129464], + &[129465], + &[129466], + &[129467], + &[129468], + &[129469], + &[129470], + &[129471], + &[129472], + &[129473], + &[129474], + &[129475], + &[129476], + &[129477], + &[129478], + &[129479], + &[129480], + &[129481], + &[129482], + &[129483], + &[129484], + &[129485], + &[129486], + &[129487], + &[129488], + &[129489], + &[129490], + &[129491], + &[129492], + &[129493], + &[129494], + &[129495], + &[129496], + &[129497], + &[129498], + &[129499], + &[129500], + &[129501], + &[129502], + &[129503], + &[129504], + &[129505], + &[129506], + &[129507], + &[129508], + &[129509], + &[129510], + &[129511], + &[129512], + &[129513], + &[129514], + &[129515], + &[129516], + &[129517], + &[129518], + &[129519], + &[129520], + &[129521], + &[129522], + &[129523], + &[129524], + &[129525], + &[129526], + &[129527], + &[129528], + &[129529], + &[129530], + &[129531], + &[129532], + &[129533], + &[129534], + &[129535], + &[129648], + &[129649], + &[129650], + &[129651], + &[129652], + &[129653], + &[129654], + &[129655], + &[129656], + &[129657], + &[129658], + &[129659], + &[129660], + &[129664], + &[129665], + &[129666], + &[129667], + &[129668], + &[129669], + &[129670], + &[129671], + &[129672], + &[129673], + &[129674], + &[129678], + &[129679], + &[129680], + &[129681], + &[129682], + &[129683], + &[129684], + &[129685], + &[129686], + &[129687], + &[129688], + &[129689], + &[129690], + &[129691], + &[129692], + &[129693], + &[129694], + &[129695], + &[129696], + &[129697], + &[129698], + &[129699], + &[129700], + &[129701], + &[129702], + &[129703], + &[129704], + &[129705], + &[129706], + &[129707], + &[129708], + &[129709], + &[129710], + &[129711], + &[129712], + &[129713], + &[129714], + &[129715], + &[129716], + &[129717], + &[129718], + &[129719], + &[129720], + &[129721], + &[129722], + &[129723], + &[129724], + &[129725], + &[129726], + &[129727], + &[129728], + &[129729], + &[129730], + &[129731], + &[129732], + &[129733], + &[129734], + &[129736], + &[129741], + &[129742], + &[129743], + &[129744], + &[129745], + &[129746], + &[129747], + &[129748], + &[129749], + &[129750], + &[129751], + &[129752], + &[129753], + &[129754], + &[129755], + &[129756], + &[129759], + &[129760], + &[129761], + &[129762], + &[129763], + &[129764], + &[129765], + &[129766], + &[129767], + &[129768], + &[129769], + &[129770], + &[129775], + &[129776], + &[129777], + &[129778], + &[129779], + &[129780], + &[129781], + &[129782], + &[129783], + &[129784], + &[169, 65039], + &[174, 65039], + &[8252, 65039], + &[8265, 65039], + &[8482, 65039], + &[8505, 65039], + &[8596, 65039], + &[8597, 65039], + &[8598, 65039], + &[8599, 65039], + &[8600, 65039], + &[8601, 65039], + &[8617, 65039], + &[8618, 65039], + &[9000, 65039], + &[9167, 65039], + &[9197, 65039], + &[9198, 65039], + &[9199, 65039], + &[9201, 65039], + &[9202, 65039], + &[9208, 65039], + &[9209, 65039], + &[9210, 65039], + &[9410, 65039], + &[9642, 65039], + &[9643, 65039], + &[9654, 65039], + &[9664, 65039], + &[9723, 65039], + &[9724, 65039], + &[9728, 65039], + &[9729, 65039], + &[9730, 65039], + &[9731, 65039], + &[9732, 65039], + &[9742, 65039], + &[9745, 65039], + &[9752, 65039], + &[9757, 65039], + &[9760, 65039], + &[9762, 65039], + &[9763, 65039], + &[9766, 65039], + &[9770, 65039], + &[9774, 65039], + &[9775, 65039], + &[9784, 65039], + &[9785, 65039], + &[9786, 65039], + &[9792, 65039], + &[9794, 65039], + &[9823, 65039], + &[9824, 65039], + &[9827, 65039], + &[9829, 65039], + &[9830, 65039], + &[9832, 65039], + &[9851, 65039], + &[9854, 65039], + &[9874, 65039], + &[9876, 65039], + &[9877, 65039], + &[9878, 65039], + &[9879, 65039], + &[9881, 65039], + &[9883, 65039], + &[9884, 65039], + &[9888, 65039], + &[9895, 65039], + &[9904, 65039], + &[9905, 65039], + &[9928, 65039], + &[9935, 65039], + &[9937, 65039], + &[9939, 65039], + &[9961, 65039], + &[9968, 65039], + &[9969, 65039], + &[9972, 65039], + &[9975, 65039], + &[9976, 65039], + &[9977, 65039], + &[9986, 65039], + &[9992, 65039], + &[9993, 65039], + &[9996, 65039], + &[9997, 65039], + &[9999, 65039], + &[10002, 65039], + &[10004, 65039], + &[10006, 65039], + &[10013, 65039], + &[10017, 65039], + &[10035, 65039], + &[10036, 65039], + &[10052, 65039], + &[10055, 65039], + &[10083, 65039], + &[10084, 65039], + &[10145, 65039], + &[10548, 65039], + &[10549, 65039], + &[11013, 65039], + &[11014, 65039], + &[11015, 65039], + &[12336, 65039], + &[12349, 65039], + &[12951, 65039], + &[12953, 65039], + &[127344, 65039], + &[127345, 65039], + &[127358, 65039], + &[127359, 65039], + &[127490, 65039], + &[127543, 65039], + &[127777, 65039], + &[127780, 65039], + &[127781, 65039], + &[127782, 65039], + &[127783, 65039], + &[127784, 65039], + &[127785, 65039], + &[127786, 65039], + &[127787, 65039], + &[127788, 65039], + &[127798, 65039], + &[127869, 65039], + &[127894, 65039], + &[127895, 65039], + &[127897, 65039], + &[127898, 65039], + &[127899, 65039], + &[127902, 65039], + &[127903, 65039], + &[127947, 65039], + &[127948, 65039], + &[127949, 65039], + &[127950, 65039], + &[127956, 65039], + &[127957, 65039], + &[127958, 65039], + &[127959, 65039], + &[127960, 65039], + &[127961, 65039], + &[127962, 65039], + &[127963, 65039], + &[127964, 65039], + &[127965, 65039], + &[127966, 65039], + &[127967, 65039], + &[127987, 65039], + &[127989, 65039], + &[127991, 65039], + &[128063, 65039], + &[128065, 65039], + &[128253, 65039], + &[128329, 65039], + &[128330, 65039], + &[128367, 65039], + &[128368, 65039], + &[128371, 65039], + &[128372, 65039], + &[128373, 65039], + &[128374, 65039], + &[128375, 65039], + &[128376, 65039], + &[128377, 65039], + &[128391, 65039], + &[128394, 65039], + &[128395, 65039], + &[128396, 65039], + &[128397, 65039], + &[128400, 65039], + &[128421, 65039], + &[128424, 65039], + &[128433, 65039], + &[128434, 65039], + &[128444, 65039], + &[128450, 65039], + &[128451, 65039], + &[128452, 65039], + &[128465, 65039], + &[128466, 65039], + &[128467, 65039], + &[128476, 65039], + &[128477, 65039], + &[128478, 65039], + &[128481, 65039], + &[128483, 65039], + &[128488, 65039], + &[128495, 65039], + &[128499, 65039], + &[128506, 65039], + &[128715, 65039], + &[128717, 65039], + &[128718, 65039], + &[128719, 65039], + &[128736, 65039], + &[128737, 65039], + &[128738, 65039], + &[128739, 65039], + &[128740, 65039], + &[128741, 65039], + &[128745, 65039], + &[128752, 65039], + &[128755, 65039], +]; + +/// Return the code point ranges of the 'Basic_Emoji' Unicode property. +pub(crate) fn basic_emoji_sets() -> &'static [&'static [u32]] { + BASIC_EMOJI.as_slice() +} + +static EMOJI_KEYCAP_SEQUENCE: &[&[u32]; 12] = &[ + &[35, 65039, 8419], + &[42, 65039, 8419], + &[48, 65039, 8419], + &[49, 65039, 8419], + &[50, 65039, 8419], + &[51, 65039, 8419], + &[52, 65039, 8419], + &[53, 65039, 8419], + &[54, 65039, 8419], + &[55, 65039, 8419], + &[56, 65039, 8419], + &[57, 65039, 8419], +]; + +/// Return the code point ranges of the 'Emoji_Keycap_Sequence' Unicode property. +pub(crate) fn emoji_keycap_sequence_sets() -> &'static [&'static [u32]] { + EMOJI_KEYCAP_SEQUENCE.as_slice() +} + +static RGI_EMOJI_FLAG_SEQUENCE: &[&[u32]; 259] = &[ + &[127462, 127464], + &[127462, 127465], + &[127462, 127466], + &[127462, 127467], + &[127462, 127468], + &[127462, 127470], + &[127462, 127473], + &[127462, 127474], + &[127462, 127476], + &[127462, 127478], + &[127462, 127479], + &[127462, 127480], + &[127462, 127481], + &[127462, 127482], + &[127462, 127484], + &[127462, 127485], + &[127462, 127487], + &[127463, 127462], + &[127463, 127463], + &[127463, 127465], + &[127463, 127466], + &[127463, 127467], + &[127463, 127468], + &[127463, 127469], + &[127463, 127470], + &[127463, 127471], + &[127463, 127473], + &[127463, 127474], + &[127463, 127475], + &[127463, 127476], + &[127463, 127478], + &[127463, 127479], + &[127463, 127480], + &[127463, 127481], + &[127463, 127483], + &[127463, 127484], + &[127463, 127486], + &[127463, 127487], + &[127464, 127462], + &[127464, 127464], + &[127464, 127465], + &[127464, 127467], + &[127464, 127468], + &[127464, 127469], + &[127464, 127470], + &[127464, 127472], + &[127464, 127473], + &[127464, 127474], + &[127464, 127475], + &[127464, 127476], + &[127464, 127477], + &[127464, 127478], + &[127464, 127479], + &[127464, 127482], + &[127464, 127483], + &[127464, 127484], + &[127464, 127485], + &[127464, 127486], + &[127464, 127487], + &[127465, 127466], + &[127465, 127468], + &[127465, 127471], + &[127465, 127472], + &[127465, 127474], + &[127465, 127476], + &[127465, 127487], + &[127466, 127462], + &[127466, 127464], + &[127466, 127466], + &[127466, 127468], + &[127466, 127469], + &[127466, 127479], + &[127466, 127480], + &[127466, 127481], + &[127466, 127482], + &[127467, 127470], + &[127467, 127471], + &[127467, 127472], + &[127467, 127474], + &[127467, 127476], + &[127467, 127479], + &[127468, 127462], + &[127468, 127463], + &[127468, 127465], + &[127468, 127466], + &[127468, 127467], + &[127468, 127468], + &[127468, 127469], + &[127468, 127470], + &[127468, 127473], + &[127468, 127474], + &[127468, 127475], + &[127468, 127477], + &[127468, 127478], + &[127468, 127479], + &[127468, 127480], + &[127468, 127481], + &[127468, 127482], + &[127468, 127484], + &[127468, 127486], + &[127469, 127472], + &[127469, 127474], + &[127469, 127475], + &[127469, 127479], + &[127469, 127481], + &[127469, 127482], + &[127470, 127464], + &[127470, 127465], + &[127470, 127466], + &[127470, 127473], + &[127470, 127474], + &[127470, 127475], + &[127470, 127476], + &[127470, 127478], + &[127470, 127479], + &[127470, 127480], + &[127470, 127481], + &[127471, 127466], + &[127471, 127474], + &[127471, 127476], + &[127471, 127477], + &[127472, 127466], + &[127472, 127468], + &[127472, 127469], + &[127472, 127470], + &[127472, 127474], + &[127472, 127475], + &[127472, 127477], + &[127472, 127479], + &[127472, 127484], + &[127472, 127486], + &[127472, 127487], + &[127473, 127462], + &[127473, 127463], + &[127473, 127464], + &[127473, 127470], + &[127473, 127472], + &[127473, 127479], + &[127473, 127480], + &[127473, 127481], + &[127473, 127482], + &[127473, 127483], + &[127473, 127486], + &[127474, 127462], + &[127474, 127464], + &[127474, 127465], + &[127474, 127466], + &[127474, 127467], + &[127474, 127468], + &[127474, 127469], + &[127474, 127472], + &[127474, 127473], + &[127474, 127474], + &[127474, 127475], + &[127474, 127476], + &[127474, 127477], + &[127474, 127478], + &[127474, 127479], + &[127474, 127480], + &[127474, 127481], + &[127474, 127482], + &[127474, 127483], + &[127474, 127484], + &[127474, 127485], + &[127474, 127486], + &[127474, 127487], + &[127475, 127462], + &[127475, 127464], + &[127475, 127466], + &[127475, 127467], + &[127475, 127468], + &[127475, 127470], + &[127475, 127473], + &[127475, 127476], + &[127475, 127477], + &[127475, 127479], + &[127475, 127482], + &[127475, 127487], + &[127476, 127474], + &[127477, 127462], + &[127477, 127466], + &[127477, 127467], + &[127477, 127468], + &[127477, 127469], + &[127477, 127472], + &[127477, 127473], + &[127477, 127474], + &[127477, 127475], + &[127477, 127479], + &[127477, 127480], + &[127477, 127481], + &[127477, 127484], + &[127477, 127486], + &[127478, 127462], + &[127479, 127466], + &[127479, 127476], + &[127479, 127480], + &[127479, 127482], + &[127479, 127484], + &[127480, 127462], + &[127480, 127463], + &[127480, 127464], + &[127480, 127465], + &[127480, 127466], + &[127480, 127468], + &[127480, 127469], + &[127480, 127470], + &[127480, 127471], + &[127480, 127472], + &[127480, 127473], + &[127480, 127474], + &[127480, 127475], + &[127480, 127476], + &[127480, 127479], + &[127480, 127480], + &[127480, 127481], + &[127480, 127483], + &[127480, 127485], + &[127480, 127486], + &[127480, 127487], + &[127481, 127462], + &[127481, 127464], + &[127481, 127465], + &[127481, 127467], + &[127481, 127468], + &[127481, 127469], + &[127481, 127471], + &[127481, 127472], + &[127481, 127473], + &[127481, 127474], + &[127481, 127475], + &[127481, 127476], + &[127481, 127479], + &[127481, 127481], + &[127481, 127483], + &[127481, 127484], + &[127481, 127487], + &[127482, 127462], + &[127482, 127468], + &[127482, 127474], + &[127482, 127475], + &[127482, 127480], + &[127482, 127486], + &[127482, 127487], + &[127483, 127462], + &[127483, 127464], + &[127483, 127466], + &[127483, 127468], + &[127483, 127470], + &[127483, 127475], + &[127483, 127482], + &[127484, 127467], + &[127484, 127480], + &[127485, 127472], + &[127486, 127466], + &[127486, 127481], + &[127487, 127462], + &[127487, 127474], + &[127487, 127484], +]; + +/// Return the code point ranges of the 'RGI_Emoji_Flag_Sequence' Unicode property. +pub(crate) fn rgi_emoji_flag_sequence_sets() -> &'static [&'static [u32]] { + RGI_EMOJI_FLAG_SEQUENCE.as_slice() +} + +static RGI_EMOJI_MODIFIER_SEQUENCE: &[&[u32]; 665] = &[ + &[9757, 127995], + &[9757, 127996], + &[9757, 127997], + &[9757, 127998], + &[9757, 127999], + &[9977, 127995], + &[9977, 127996], + &[9977, 127997], + &[9977, 127998], + &[9977, 127999], + &[9994, 127995], + &[9994, 127996], + &[9994, 127997], + &[9994, 127998], + &[9994, 127999], + &[9995, 127995], + &[9995, 127996], + &[9995, 127997], + &[9995, 127998], + &[9995, 127999], + &[9996, 127995], + &[9996, 127996], + &[9996, 127997], + &[9996, 127998], + &[9996, 127999], + &[9997, 127995], + &[9997, 127996], + &[9997, 127997], + &[9997, 127998], + &[9997, 127999], + &[127877, 127995], + &[127877, 127996], + &[127877, 127997], + &[127877, 127998], + &[127877, 127999], + &[127938, 127995], + &[127938, 127996], + &[127938, 127997], + &[127938, 127998], + &[127938, 127999], + &[127939, 127995], + &[127939, 127996], + &[127939, 127997], + &[127939, 127998], + &[127939, 127999], + &[127940, 127995], + &[127940, 127996], + &[127940, 127997], + &[127940, 127998], + &[127940, 127999], + &[127943, 127995], + &[127943, 127996], + &[127943, 127997], + &[127943, 127998], + &[127943, 127999], + &[127946, 127995], + &[127946, 127996], + &[127946, 127997], + &[127946, 127998], + &[127946, 127999], + &[127947, 127995], + &[127947, 127996], + &[127947, 127997], + &[127947, 127998], + &[127947, 127999], + &[127948, 127995], + &[127948, 127996], + &[127948, 127997], + &[127948, 127998], + &[127948, 127999], + &[128066, 127995], + &[128066, 127996], + &[128066, 127997], + &[128066, 127998], + &[128066, 127999], + &[128067, 127995], + &[128067, 127996], + &[128067, 127997], + &[128067, 127998], + &[128067, 127999], + &[128070, 127995], + &[128070, 127996], + &[128070, 127997], + &[128070, 127998], + &[128070, 127999], + &[128071, 127995], + &[128071, 127996], + &[128071, 127997], + &[128071, 127998], + &[128071, 127999], + &[128072, 127995], + &[128072, 127996], + &[128072, 127997], + &[128072, 127998], + &[128072, 127999], + &[128073, 127995], + &[128073, 127996], + &[128073, 127997], + &[128073, 127998], + &[128073, 127999], + &[128074, 127995], + &[128074, 127996], + &[128074, 127997], + &[128074, 127998], + &[128074, 127999], + &[128075, 127995], + &[128075, 127996], + &[128075, 127997], + &[128075, 127998], + &[128075, 127999], + &[128076, 127995], + &[128076, 127996], + &[128076, 127997], + &[128076, 127998], + &[128076, 127999], + &[128077, 127995], + &[128077, 127996], + &[128077, 127997], + &[128077, 127998], + &[128077, 127999], + &[128078, 127995], + &[128078, 127996], + &[128078, 127997], + &[128078, 127998], + &[128078, 127999], + &[128079, 127995], + &[128079, 127996], + &[128079, 127997], + &[128079, 127998], + &[128079, 127999], + &[128080, 127995], + &[128080, 127996], + &[128080, 127997], + &[128080, 127998], + &[128080, 127999], + &[128102, 127995], + &[128102, 127996], + &[128102, 127997], + &[128102, 127998], + &[128102, 127999], + &[128103, 127995], + &[128103, 127996], + &[128103, 127997], + &[128103, 127998], + &[128103, 127999], + &[128104, 127995], + &[128104, 127996], + &[128104, 127997], + &[128104, 127998], + &[128104, 127999], + &[128105, 127995], + &[128105, 127996], + &[128105, 127997], + &[128105, 127998], + &[128105, 127999], + &[128107, 127995], + &[128107, 127996], + &[128107, 127997], + &[128107, 127998], + &[128107, 127999], + &[128108, 127995], + &[128108, 127996], + &[128108, 127997], + &[128108, 127998], + &[128108, 127999], + &[128109, 127995], + &[128109, 127996], + &[128109, 127997], + &[128109, 127998], + &[128109, 127999], + &[128110, 127995], + &[128110, 127996], + &[128110, 127997], + &[128110, 127998], + &[128110, 127999], + &[128111, 127995], + &[128111, 127996], + &[128111, 127997], + &[128111, 127998], + &[128111, 127999], + &[128112, 127995], + &[128112, 127996], + &[128112, 127997], + &[128112, 127998], + &[128112, 127999], + &[128113, 127995], + &[128113, 127996], + &[128113, 127997], + &[128113, 127998], + &[128113, 127999], + &[128114, 127995], + &[128114, 127996], + &[128114, 127997], + &[128114, 127998], + &[128114, 127999], + &[128115, 127995], + &[128115, 127996], + &[128115, 127997], + &[128115, 127998], + &[128115, 127999], + &[128116, 127995], + &[128116, 127996], + &[128116, 127997], + &[128116, 127998], + &[128116, 127999], + &[128117, 127995], + &[128117, 127996], + &[128117, 127997], + &[128117, 127998], + &[128117, 127999], + &[128118, 127995], + &[128118, 127996], + &[128118, 127997], + &[128118, 127998], + &[128118, 127999], + &[128119, 127995], + &[128119, 127996], + &[128119, 127997], + &[128119, 127998], + &[128119, 127999], + &[128120, 127995], + &[128120, 127996], + &[128120, 127997], + &[128120, 127998], + &[128120, 127999], + &[128124, 127995], + &[128124, 127996], + &[128124, 127997], + &[128124, 127998], + &[128124, 127999], + &[128129, 127995], + &[128129, 127996], + &[128129, 127997], + &[128129, 127998], + &[128129, 127999], + &[128130, 127995], + &[128130, 127996], + &[128130, 127997], + &[128130, 127998], + &[128130, 127999], + &[128131, 127995], + &[128131, 127996], + &[128131, 127997], + &[128131, 127998], + &[128131, 127999], + &[128133, 127995], + &[128133, 127996], + &[128133, 127997], + &[128133, 127998], + &[128133, 127999], + &[128134, 127995], + &[128134, 127996], + &[128134, 127997], + &[128134, 127998], + &[128134, 127999], + &[128135, 127995], + &[128135, 127996], + &[128135, 127997], + &[128135, 127998], + &[128135, 127999], + &[128143, 127995], + &[128143, 127996], + &[128143, 127997], + &[128143, 127998], + &[128143, 127999], + &[128145, 127995], + &[128145, 127996], + &[128145, 127997], + &[128145, 127998], + &[128145, 127999], + &[128170, 127995], + &[128170, 127996], + &[128170, 127997], + &[128170, 127998], + &[128170, 127999], + &[128372, 127995], + &[128372, 127996], + &[128372, 127997], + &[128372, 127998], + &[128372, 127999], + &[128373, 127995], + &[128373, 127996], + &[128373, 127997], + &[128373, 127998], + &[128373, 127999], + &[128378, 127995], + &[128378, 127996], + &[128378, 127997], + &[128378, 127998], + &[128378, 127999], + &[128400, 127995], + &[128400, 127996], + &[128400, 127997], + &[128400, 127998], + &[128400, 127999], + &[128405, 127995], + &[128405, 127996], + &[128405, 127997], + &[128405, 127998], + &[128405, 127999], + &[128406, 127995], + &[128406, 127996], + &[128406, 127997], + &[128406, 127998], + &[128406, 127999], + &[128581, 127995], + &[128581, 127996], + &[128581, 127997], + &[128581, 127998], + &[128581, 127999], + &[128582, 127995], + &[128582, 127996], + &[128582, 127997], + &[128582, 127998], + &[128582, 127999], + &[128583, 127995], + &[128583, 127996], + &[128583, 127997], + &[128583, 127998], + &[128583, 127999], + &[128587, 127995], + &[128587, 127996], + &[128587, 127997], + &[128587, 127998], + &[128587, 127999], + &[128588, 127995], + &[128588, 127996], + &[128588, 127997], + &[128588, 127998], + &[128588, 127999], + &[128589, 127995], + &[128589, 127996], + &[128589, 127997], + &[128589, 127998], + &[128589, 127999], + &[128590, 127995], + &[128590, 127996], + &[128590, 127997], + &[128590, 127998], + &[128590, 127999], + &[128591, 127995], + &[128591, 127996], + &[128591, 127997], + &[128591, 127998], + &[128591, 127999], + &[128675, 127995], + &[128675, 127996], + &[128675, 127997], + &[128675, 127998], + &[128675, 127999], + &[128692, 127995], + &[128692, 127996], + &[128692, 127997], + &[128692, 127998], + &[128692, 127999], + &[128693, 127995], + &[128693, 127996], + &[128693, 127997], + &[128693, 127998], + &[128693, 127999], + &[128694, 127995], + &[128694, 127996], + &[128694, 127997], + &[128694, 127998], + &[128694, 127999], + &[128704, 127995], + &[128704, 127996], + &[128704, 127997], + &[128704, 127998], + &[128704, 127999], + &[128716, 127995], + &[128716, 127996], + &[128716, 127997], + &[128716, 127998], + &[128716, 127999], + &[129292, 127995], + &[129292, 127996], + &[129292, 127997], + &[129292, 127998], + &[129292, 127999], + &[129295, 127995], + &[129295, 127996], + &[129295, 127997], + &[129295, 127998], + &[129295, 127999], + &[129304, 127995], + &[129304, 127996], + &[129304, 127997], + &[129304, 127998], + &[129304, 127999], + &[129305, 127995], + &[129305, 127996], + &[129305, 127997], + &[129305, 127998], + &[129305, 127999], + &[129306, 127995], + &[129306, 127996], + &[129306, 127997], + &[129306, 127998], + &[129306, 127999], + &[129307, 127995], + &[129307, 127996], + &[129307, 127997], + &[129307, 127998], + &[129307, 127999], + &[129308, 127995], + &[129308, 127996], + &[129308, 127997], + &[129308, 127998], + &[129308, 127999], + &[129309, 127995], + &[129309, 127996], + &[129309, 127997], + &[129309, 127998], + &[129309, 127999], + &[129310, 127995], + &[129310, 127996], + &[129310, 127997], + &[129310, 127998], + &[129310, 127999], + &[129311, 127995], + &[129311, 127996], + &[129311, 127997], + &[129311, 127998], + &[129311, 127999], + &[129318, 127995], + &[129318, 127996], + &[129318, 127997], + &[129318, 127998], + &[129318, 127999], + &[129328, 127995], + &[129328, 127996], + &[129328, 127997], + &[129328, 127998], + &[129328, 127999], + &[129329, 127995], + &[129329, 127996], + &[129329, 127997], + &[129329, 127998], + &[129329, 127999], + &[129330, 127995], + &[129330, 127996], + &[129330, 127997], + &[129330, 127998], + &[129330, 127999], + &[129331, 127995], + &[129331, 127996], + &[129331, 127997], + &[129331, 127998], + &[129331, 127999], + &[129332, 127995], + &[129332, 127996], + &[129332, 127997], + &[129332, 127998], + &[129332, 127999], + &[129333, 127995], + &[129333, 127996], + &[129333, 127997], + &[129333, 127998], + &[129333, 127999], + &[129334, 127995], + &[129334, 127996], + &[129334, 127997], + &[129334, 127998], + &[129334, 127999], + &[129335, 127995], + &[129335, 127996], + &[129335, 127997], + &[129335, 127998], + &[129335, 127999], + &[129336, 127995], + &[129336, 127996], + &[129336, 127997], + &[129336, 127998], + &[129336, 127999], + &[129337, 127995], + &[129337, 127996], + &[129337, 127997], + &[129337, 127998], + &[129337, 127999], + &[129340, 127995], + &[129340, 127996], + &[129340, 127997], + &[129340, 127998], + &[129340, 127999], + &[129341, 127995], + &[129341, 127996], + &[129341, 127997], + &[129341, 127998], + &[129341, 127999], + &[129342, 127995], + &[129342, 127996], + &[129342, 127997], + &[129342, 127998], + &[129342, 127999], + &[129399, 127995], + &[129399, 127996], + &[129399, 127997], + &[129399, 127998], + &[129399, 127999], + &[129461, 127995], + &[129461, 127996], + &[129461, 127997], + &[129461, 127998], + &[129461, 127999], + &[129462, 127995], + &[129462, 127996], + &[129462, 127997], + &[129462, 127998], + &[129462, 127999], + &[129464, 127995], + &[129464, 127996], + &[129464, 127997], + &[129464, 127998], + &[129464, 127999], + &[129465, 127995], + &[129465, 127996], + &[129465, 127997], + &[129465, 127998], + &[129465, 127999], + &[129467, 127995], + &[129467, 127996], + &[129467, 127997], + &[129467, 127998], + &[129467, 127999], + &[129485, 127995], + &[129485, 127996], + &[129485, 127997], + &[129485, 127998], + &[129485, 127999], + &[129486, 127995], + &[129486, 127996], + &[129486, 127997], + &[129486, 127998], + &[129486, 127999], + &[129487, 127995], + &[129487, 127996], + &[129487, 127997], + &[129487, 127998], + &[129487, 127999], + &[129489, 127995], + &[129489, 127996], + &[129489, 127997], + &[129489, 127998], + &[129489, 127999], + &[129490, 127995], + &[129490, 127996], + &[129490, 127997], + &[129490, 127998], + &[129490, 127999], + &[129491, 127995], + &[129491, 127996], + &[129491, 127997], + &[129491, 127998], + &[129491, 127999], + &[129492, 127995], + &[129492, 127996], + &[129492, 127997], + &[129492, 127998], + &[129492, 127999], + &[129493, 127995], + &[129493, 127996], + &[129493, 127997], + &[129493, 127998], + &[129493, 127999], + &[129494, 127995], + &[129494, 127996], + &[129494, 127997], + &[129494, 127998], + &[129494, 127999], + &[129495, 127995], + &[129495, 127996], + &[129495, 127997], + &[129495, 127998], + &[129495, 127999], + &[129496, 127995], + &[129496, 127996], + &[129496, 127997], + &[129496, 127998], + &[129496, 127999], + &[129497, 127995], + &[129497, 127996], + &[129497, 127997], + &[129497, 127998], + &[129497, 127999], + &[129498, 127995], + &[129498, 127996], + &[129498, 127997], + &[129498, 127998], + &[129498, 127999], + &[129499, 127995], + &[129499, 127996], + &[129499, 127997], + &[129499, 127998], + &[129499, 127999], + &[129500, 127995], + &[129500, 127996], + &[129500, 127997], + &[129500, 127998], + &[129500, 127999], + &[129501, 127995], + &[129501, 127996], + &[129501, 127997], + &[129501, 127998], + &[129501, 127999], + &[129731, 127995], + &[129731, 127996], + &[129731, 127997], + &[129731, 127998], + &[129731, 127999], + &[129732, 127995], + &[129732, 127996], + &[129732, 127997], + &[129732, 127998], + &[129732, 127999], + &[129733, 127995], + &[129733, 127996], + &[129733, 127997], + &[129733, 127998], + &[129733, 127999], + &[129776, 127995], + &[129776, 127996], + &[129776, 127997], + &[129776, 127998], + &[129776, 127999], + &[129777, 127995], + &[129777, 127996], + &[129777, 127997], + &[129777, 127998], + &[129777, 127999], + &[129778, 127995], + &[129778, 127996], + &[129778, 127997], + &[129778, 127998], + &[129778, 127999], + &[129779, 127995], + &[129779, 127996], + &[129779, 127997], + &[129779, 127998], + &[129779, 127999], + &[129780, 127995], + &[129780, 127996], + &[129780, 127997], + &[129780, 127998], + &[129780, 127999], + &[129781, 127995], + &[129781, 127996], + &[129781, 127997], + &[129781, 127998], + &[129781, 127999], + &[129782, 127995], + &[129782, 127996], + &[129782, 127997], + &[129782, 127998], + &[129782, 127999], + &[129783, 127995], + &[129783, 127996], + &[129783, 127997], + &[129783, 127998], + &[129783, 127999], + &[129784, 127995], + &[129784, 127996], + &[129784, 127997], + &[129784, 127998], + &[129784, 127999], +]; + +/// Return the code point ranges of the 'RGI_Emoji_Modifier_Sequence' Unicode property. +pub(crate) fn rgi_emoji_modifier_sequence_sets() -> &'static [&'static [u32]] { + RGI_EMOJI_MODIFIER_SEQUENCE.as_slice() +} + +static RGI_EMOJI_TAG_SEQUENCE: &[&[u32]; 3] = &[ + &[127988, 917607, 917602, 917605, 917614, 917607, 917631], + &[127988, 917607, 917602, 917619, 917603, 917620, 917631], + &[127988, 917607, 917602, 917623, 917612, 917619, 917631], +]; + +/// Return the code point ranges of the 'RGI_Emoji_Tag_Sequence' Unicode property. +pub(crate) fn rgi_emoji_tag_sequence_sets() -> &'static [&'static [u32]] { + RGI_EMOJI_TAG_SEQUENCE.as_slice() +} + +static RGI_EMOJI_ZWJ_SEQUENCE: &[&[u32]; 1614] = &[ + &[128104, 8205, 10084, 65039, 8205, 128104], + &[128104, 8205, 10084, 65039, 8205, 128139, 8205, 128104], + &[128104, 8205, 128102], + &[128104, 8205, 128102, 8205, 128102], + &[128104, 8205, 128103], + &[128104, 8205, 128103, 8205, 128102], + &[128104, 8205, 128103, 8205, 128103], + &[128104, 8205, 128104, 8205, 128102], + &[128104, 8205, 128104, 8205, 128102, 8205, 128102], + &[128104, 8205, 128104, 8205, 128103], + &[128104, 8205, 128104, 8205, 128103, 8205, 128102], + &[128104, 8205, 128104, 8205, 128103, 8205, 128103], + &[128104, 8205, 128105, 8205, 128102], + &[128104, 8205, 128105, 8205, 128102, 8205, 128102], + &[128104, 8205, 128105, 8205, 128103], + &[128104, 8205, 128105, 8205, 128103, 8205, 128102], + &[128104, 8205, 128105, 8205, 128103, 8205, 128103], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127995, 8205, 128048, 8205, 128104, 127996], + &[128104, 127995, 8205, 128048, 8205, 128104, 127997], + &[128104, 127995, 8205, 128048, 8205, 128104, 127998], + &[128104, 127995, 8205, 128048, 8205, 128104, 127999], + &[128104, 127995, 8205, 129309, 8205, 128104, 127996], + &[128104, 127995, 8205, 129309, 8205, 128104, 127997], + &[128104, 127995, 8205, 129309, 8205, 128104, 127998], + &[128104, 127995, 8205, 129309, 8205, 128104, 127999], + &[128104, 127995, 8205, 129775, 8205, 128104, 127996], + &[128104, 127995, 8205, 129775, 8205, 128104, 127997], + &[128104, 127995, 8205, 129775, 8205, 128104, 127998], + &[128104, 127995, 8205, 129775, 8205, 128104, 127999], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127996, 8205, 128048, 8205, 128104, 127995], + &[128104, 127996, 8205, 128048, 8205, 128104, 127997], + &[128104, 127996, 8205, 128048, 8205, 128104, 127998], + &[128104, 127996, 8205, 128048, 8205, 128104, 127999], + &[128104, 127996, 8205, 129309, 8205, 128104, 127995], + &[128104, 127996, 8205, 129309, 8205, 128104, 127997], + &[128104, 127996, 8205, 129309, 8205, 128104, 127998], + &[128104, 127996, 8205, 129309, 8205, 128104, 127999], + &[128104, 127996, 8205, 129775, 8205, 128104, 127995], + &[128104, 127996, 8205, 129775, 8205, 128104, 127997], + &[128104, 127996, 8205, 129775, 8205, 128104, 127998], + &[128104, 127996, 8205, 129775, 8205, 128104, 127999], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127997, 8205, 128048, 8205, 128104, 127995], + &[128104, 127997, 8205, 128048, 8205, 128104, 127996], + &[128104, 127997, 8205, 128048, 8205, 128104, 127998], + &[128104, 127997, 8205, 128048, 8205, 128104, 127999], + &[128104, 127997, 8205, 129309, 8205, 128104, 127995], + &[128104, 127997, 8205, 129309, 8205, 128104, 127996], + &[128104, 127997, 8205, 129309, 8205, 128104, 127998], + &[128104, 127997, 8205, 129309, 8205, 128104, 127999], + &[128104, 127997, 8205, 129775, 8205, 128104, 127995], + &[128104, 127997, 8205, 129775, 8205, 128104, 127996], + &[128104, 127997, 8205, 129775, 8205, 128104, 127998], + &[128104, 127997, 8205, 129775, 8205, 128104, 127999], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127998, 8205, 128048, 8205, 128104, 127995], + &[128104, 127998, 8205, 128048, 8205, 128104, 127996], + &[128104, 127998, 8205, 128048, 8205, 128104, 127997], + &[128104, 127998, 8205, 128048, 8205, 128104, 127999], + &[128104, 127998, 8205, 129309, 8205, 128104, 127995], + &[128104, 127998, 8205, 129309, 8205, 128104, 127996], + &[128104, 127998, 8205, 129309, 8205, 128104, 127997], + &[128104, 127998, 8205, 129309, 8205, 128104, 127999], + &[128104, 127998, 8205, 129775, 8205, 128104, 127995], + &[128104, 127998, 8205, 129775, 8205, 128104, 127996], + &[128104, 127998, 8205, 129775, 8205, 128104, 127997], + &[128104, 127998, 8205, 129775, 8205, 128104, 127999], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127999, 8205, 128048, 8205, 128104, 127995], + &[128104, 127999, 8205, 128048, 8205, 128104, 127996], + &[128104, 127999, 8205, 128048, 8205, 128104, 127997], + &[128104, 127999, 8205, 128048, 8205, 128104, 127998], + &[128104, 127999, 8205, 129309, 8205, 128104, 127995], + &[128104, 127999, 8205, 129309, 8205, 128104, 127996], + &[128104, 127999, 8205, 129309, 8205, 128104, 127997], + &[128104, 127999, 8205, 129309, 8205, 128104, 127998], + &[128104, 127999, 8205, 129775, 8205, 128104, 127995], + &[128104, 127999, 8205, 129775, 8205, 128104, 127996], + &[128104, 127999, 8205, 129775, 8205, 128104, 127997], + &[128104, 127999, 8205, 129775, 8205, 128104, 127998], + &[128105, 8205, 10084, 65039, 8205, 128104], + &[128105, 8205, 10084, 65039, 8205, 128105], + &[128105, 8205, 10084, 65039, 8205, 128139, 8205, 128104], + &[128105, 8205, 10084, 65039, 8205, 128139, 8205, 128105], + &[128105, 8205, 128102], + &[128105, 8205, 128102, 8205, 128102], + &[128105, 8205, 128103], + &[128105, 8205, 128103, 8205, 128102], + &[128105, 8205, 128103, 8205, 128103], + &[128105, 8205, 128105, 8205, 128102], + &[128105, 8205, 128105, 8205, 128102, 8205, 128102], + &[128105, 8205, 128105, 8205, 128103], + &[128105, 8205, 128105, 8205, 128103, 8205, 128102], + &[128105, 8205, 128105, 8205, 128103, 8205, 128103], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127995, 8205, 128048, 8205, 128105, 127996], + &[128105, 127995, 8205, 128048, 8205, 128105, 127997], + &[128105, 127995, 8205, 128048, 8205, 128105, 127998], + &[128105, 127995, 8205, 128048, 8205, 128105, 127999], + &[128105, 127995, 8205, 129309, 8205, 128104, 127996], + &[128105, 127995, 8205, 129309, 8205, 128104, 127997], + &[128105, 127995, 8205, 129309, 8205, 128104, 127998], + &[128105, 127995, 8205, 129309, 8205, 128104, 127999], + &[128105, 127995, 8205, 129309, 8205, 128105, 127996], + &[128105, 127995, 8205, 129309, 8205, 128105, 127997], + &[128105, 127995, 8205, 129309, 8205, 128105, 127998], + &[128105, 127995, 8205, 129309, 8205, 128105, 127999], + &[128105, 127995, 8205, 129775, 8205, 128105, 127996], + &[128105, 127995, 8205, 129775, 8205, 128105, 127997], + &[128105, 127995, 8205, 129775, 8205, 128105, 127998], + &[128105, 127995, 8205, 129775, 8205, 128105, 127999], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127996, 8205, 128048, 8205, 128105, 127995], + &[128105, 127996, 8205, 128048, 8205, 128105, 127997], + &[128105, 127996, 8205, 128048, 8205, 128105, 127998], + &[128105, 127996, 8205, 128048, 8205, 128105, 127999], + &[128105, 127996, 8205, 129309, 8205, 128104, 127995], + &[128105, 127996, 8205, 129309, 8205, 128104, 127997], + &[128105, 127996, 8205, 129309, 8205, 128104, 127998], + &[128105, 127996, 8205, 129309, 8205, 128104, 127999], + &[128105, 127996, 8205, 129309, 8205, 128105, 127995], + &[128105, 127996, 8205, 129309, 8205, 128105, 127997], + &[128105, 127996, 8205, 129309, 8205, 128105, 127998], + &[128105, 127996, 8205, 129309, 8205, 128105, 127999], + &[128105, 127996, 8205, 129775, 8205, 128105, 127995], + &[128105, 127996, 8205, 129775, 8205, 128105, 127997], + &[128105, 127996, 8205, 129775, 8205, 128105, 127998], + &[128105, 127996, 8205, 129775, 8205, 128105, 127999], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127997, 8205, 128048, 8205, 128105, 127995], + &[128105, 127997, 8205, 128048, 8205, 128105, 127996], + &[128105, 127997, 8205, 128048, 8205, 128105, 127998], + &[128105, 127997, 8205, 128048, 8205, 128105, 127999], + &[128105, 127997, 8205, 129309, 8205, 128104, 127995], + &[128105, 127997, 8205, 129309, 8205, 128104, 127996], + &[128105, 127997, 8205, 129309, 8205, 128104, 127998], + &[128105, 127997, 8205, 129309, 8205, 128104, 127999], + &[128105, 127997, 8205, 129309, 8205, 128105, 127995], + &[128105, 127997, 8205, 129309, 8205, 128105, 127996], + &[128105, 127997, 8205, 129309, 8205, 128105, 127998], + &[128105, 127997, 8205, 129309, 8205, 128105, 127999], + &[128105, 127997, 8205, 129775, 8205, 128105, 127995], + &[128105, 127997, 8205, 129775, 8205, 128105, 127996], + &[128105, 127997, 8205, 129775, 8205, 128105, 127998], + &[128105, 127997, 8205, 129775, 8205, 128105, 127999], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127998, 8205, 128048, 8205, 128105, 127995], + &[128105, 127998, 8205, 128048, 8205, 128105, 127996], + &[128105, 127998, 8205, 128048, 8205, 128105, 127997], + &[128105, 127998, 8205, 128048, 8205, 128105, 127999], + &[128105, 127998, 8205, 129309, 8205, 128104, 127995], + &[128105, 127998, 8205, 129309, 8205, 128104, 127996], + &[128105, 127998, 8205, 129309, 8205, 128104, 127997], + &[128105, 127998, 8205, 129309, 8205, 128104, 127999], + &[128105, 127998, 8205, 129309, 8205, 128105, 127995], + &[128105, 127998, 8205, 129309, 8205, 128105, 127996], + &[128105, 127998, 8205, 129309, 8205, 128105, 127997], + &[128105, 127998, 8205, 129309, 8205, 128105, 127999], + &[128105, 127998, 8205, 129775, 8205, 128105, 127995], + &[128105, 127998, 8205, 129775, 8205, 128105, 127996], + &[128105, 127998, 8205, 129775, 8205, 128105, 127997], + &[128105, 127998, 8205, 129775, 8205, 128105, 127999], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127999, 8205, 128048, 8205, 128105, 127995], + &[128105, 127999, 8205, 128048, 8205, 128105, 127996], + &[128105, 127999, 8205, 128048, 8205, 128105, 127997], + &[128105, 127999, 8205, 128048, 8205, 128105, 127998], + &[128105, 127999, 8205, 129309, 8205, 128104, 127995], + &[128105, 127999, 8205, 129309, 8205, 128104, 127996], + &[128105, 127999, 8205, 129309, 8205, 128104, 127997], + &[128105, 127999, 8205, 129309, 8205, 128104, 127998], + &[128105, 127999, 8205, 129309, 8205, 128105, 127995], + &[128105, 127999, 8205, 129309, 8205, 128105, 127996], + &[128105, 127999, 8205, 129309, 8205, 128105, 127997], + &[128105, 127999, 8205, 129309, 8205, 128105, 127998], + &[128105, 127999, 8205, 129775, 8205, 128105, 127995], + &[128105, 127999, 8205, 129775, 8205, 128105, 127996], + &[128105, 127999, 8205, 129775, 8205, 128105, 127997], + &[128105, 127999, 8205, 129775, 8205, 128105, 127998], + &[129489, 8205, 129309, 8205, 129489], + &[129489, 8205, 129489, 8205, 129490], + &[129489, 8205, 129489, 8205, 129490, 8205, 129490], + &[129489, 8205, 129490], + &[129489, 8205, 129490, 8205, 129490], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127995, 8205, 129309, 8205, 129489, 127995], + &[129489, 127995, 8205, 129309, 8205, 129489, 127996], + &[129489, 127995, 8205, 129309, 8205, 129489, 127997], + &[129489, 127995, 8205, 129309, 8205, 129489, 127998], + &[129489, 127995, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127996, 8205, 129309, 8205, 129489, 127995], + &[129489, 127996, 8205, 129309, 8205, 129489, 127996], + &[129489, 127996, 8205, 129309, 8205, 129489, 127997], + &[129489, 127996, 8205, 129309, 8205, 129489, 127998], + &[129489, 127996, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127997, 8205, 129309, 8205, 129489, 127995], + &[129489, 127997, 8205, 129309, 8205, 129489, 127996], + &[129489, 127997, 8205, 129309, 8205, 129489, 127997], + &[129489, 127997, 8205, 129309, 8205, 129489, 127998], + &[129489, 127997, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127998, 8205, 129309, 8205, 129489, 127995], + &[129489, 127998, 8205, 129309, 8205, 129489, 127996], + &[129489, 127998, 8205, 129309, 8205, 129489, 127997], + &[129489, 127998, 8205, 129309, 8205, 129489, 127998], + &[129489, 127998, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127999, 8205, 129309, 8205, 129489, 127995], + &[129489, 127999, 8205, 129309, 8205, 129489, 127996], + &[129489, 127999, 8205, 129309, 8205, 129489, 127997], + &[129489, 127999, 8205, 129309, 8205, 129489, 127998], + &[129489, 127999, 8205, 129309, 8205, 129489, 127999], + &[129777, 127995, 8205, 129778, 127996], + &[129777, 127995, 8205, 129778, 127997], + &[129777, 127995, 8205, 129778, 127998], + &[129777, 127995, 8205, 129778, 127999], + &[129777, 127996, 8205, 129778, 127995], + &[129777, 127996, 8205, 129778, 127997], + &[129777, 127996, 8205, 129778, 127998], + &[129777, 127996, 8205, 129778, 127999], + &[129777, 127997, 8205, 129778, 127995], + &[129777, 127997, 8205, 129778, 127996], + &[129777, 127997, 8205, 129778, 127998], + &[129777, 127997, 8205, 129778, 127999], + &[129777, 127998, 8205, 129778, 127995], + &[129777, 127998, 8205, 129778, 127996], + &[129777, 127998, 8205, 129778, 127997], + &[129777, 127998, 8205, 129778, 127999], + &[129777, 127999, 8205, 129778, 127995], + &[129777, 127999, 8205, 129778, 127996], + &[129777, 127999, 8205, 129778, 127997], + &[129777, 127999, 8205, 129778, 127998], + &[127939, 8205, 10145, 65039], + &[127939, 127995, 8205, 10145, 65039], + &[127939, 127996, 8205, 10145, 65039], + &[127939, 127997, 8205, 10145, 65039], + &[127939, 127998, 8205, 10145, 65039], + &[127939, 127999, 8205, 10145, 65039], + &[128104, 8205, 9877, 65039], + &[128104, 8205, 9878, 65039], + &[128104, 8205, 9992, 65039], + &[128104, 8205, 127806], + &[128104, 8205, 127859], + &[128104, 8205, 127868], + &[128104, 8205, 127891], + &[128104, 8205, 127908], + &[128104, 8205, 127912], + &[128104, 8205, 127979], + &[128104, 8205, 127981], + &[128104, 8205, 128187], + &[128104, 8205, 128188], + &[128104, 8205, 128295], + &[128104, 8205, 128300], + &[128104, 8205, 128640], + &[128104, 8205, 128658], + &[128104, 8205, 129455], + &[128104, 8205, 129455, 8205, 10145, 65039], + &[128104, 8205, 129468], + &[128104, 8205, 129468, 8205, 10145, 65039], + &[128104, 8205, 129469], + &[128104, 8205, 129469, 8205, 10145, 65039], + &[128104, 127995, 8205, 9877, 65039], + &[128104, 127995, 8205, 9878, 65039], + &[128104, 127995, 8205, 9992, 65039], + &[128104, 127995, 8205, 127806], + &[128104, 127995, 8205, 127859], + &[128104, 127995, 8205, 127868], + &[128104, 127995, 8205, 127891], + &[128104, 127995, 8205, 127908], + &[128104, 127995, 8205, 127912], + &[128104, 127995, 8205, 127979], + &[128104, 127995, 8205, 127981], + &[128104, 127995, 8205, 128187], + &[128104, 127995, 8205, 128188], + &[128104, 127995, 8205, 128295], + &[128104, 127995, 8205, 128300], + &[128104, 127995, 8205, 128640], + &[128104, 127995, 8205, 128658], + &[128104, 127995, 8205, 129455], + &[128104, 127995, 8205, 129455, 8205, 10145, 65039], + &[128104, 127995, 8205, 129468], + &[128104, 127995, 8205, 129468, 8205, 10145, 65039], + &[128104, 127995, 8205, 129469], + &[128104, 127995, 8205, 129469, 8205, 10145, 65039], + &[128104, 127996, 8205, 9877, 65039], + &[128104, 127996, 8205, 9878, 65039], + &[128104, 127996, 8205, 9992, 65039], + &[128104, 127996, 8205, 127806], + &[128104, 127996, 8205, 127859], + &[128104, 127996, 8205, 127868], + &[128104, 127996, 8205, 127891], + &[128104, 127996, 8205, 127908], + &[128104, 127996, 8205, 127912], + &[128104, 127996, 8205, 127979], + &[128104, 127996, 8205, 127981], + &[128104, 127996, 8205, 128187], + &[128104, 127996, 8205, 128188], + &[128104, 127996, 8205, 128295], + &[128104, 127996, 8205, 128300], + &[128104, 127996, 8205, 128640], + &[128104, 127996, 8205, 128658], + &[128104, 127996, 8205, 129455], + &[128104, 127996, 8205, 129455, 8205, 10145, 65039], + &[128104, 127996, 8205, 129468], + &[128104, 127996, 8205, 129468, 8205, 10145, 65039], + &[128104, 127996, 8205, 129469], + &[128104, 127996, 8205, 129469, 8205, 10145, 65039], + &[128104, 127997, 8205, 9877, 65039], + &[128104, 127997, 8205, 9878, 65039], + &[128104, 127997, 8205, 9992, 65039], + &[128104, 127997, 8205, 127806], + &[128104, 127997, 8205, 127859], + &[128104, 127997, 8205, 127868], + &[128104, 127997, 8205, 127891], + &[128104, 127997, 8205, 127908], + &[128104, 127997, 8205, 127912], + &[128104, 127997, 8205, 127979], + &[128104, 127997, 8205, 127981], + &[128104, 127997, 8205, 128187], + &[128104, 127997, 8205, 128188], + &[128104, 127997, 8205, 128295], + &[128104, 127997, 8205, 128300], + &[128104, 127997, 8205, 128640], + &[128104, 127997, 8205, 128658], + &[128104, 127997, 8205, 129455], + &[128104, 127997, 8205, 129455, 8205, 10145, 65039], + &[128104, 127997, 8205, 129468], + &[128104, 127997, 8205, 129468, 8205, 10145, 65039], + &[128104, 127997, 8205, 129469], + &[128104, 127997, 8205, 129469, 8205, 10145, 65039], + &[128104, 127998, 8205, 9877, 65039], + &[128104, 127998, 8205, 9878, 65039], + &[128104, 127998, 8205, 9992, 65039], + &[128104, 127998, 8205, 127806], + &[128104, 127998, 8205, 127859], + &[128104, 127998, 8205, 127868], + &[128104, 127998, 8205, 127891], + &[128104, 127998, 8205, 127908], + &[128104, 127998, 8205, 127912], + &[128104, 127998, 8205, 127979], + &[128104, 127998, 8205, 127981], + &[128104, 127998, 8205, 128187], + &[128104, 127998, 8205, 128188], + &[128104, 127998, 8205, 128295], + &[128104, 127998, 8205, 128300], + &[128104, 127998, 8205, 128640], + &[128104, 127998, 8205, 128658], + &[128104, 127998, 8205, 129455], + &[128104, 127998, 8205, 129455, 8205, 10145, 65039], + &[128104, 127998, 8205, 129468], + &[128104, 127998, 8205, 129468, 8205, 10145, 65039], + &[128104, 127998, 8205, 129469], + &[128104, 127998, 8205, 129469, 8205, 10145, 65039], + &[128104, 127999, 8205, 9877, 65039], + &[128104, 127999, 8205, 9878, 65039], + &[128104, 127999, 8205, 9992, 65039], + &[128104, 127999, 8205, 127806], + &[128104, 127999, 8205, 127859], + &[128104, 127999, 8205, 127868], + &[128104, 127999, 8205, 127891], + &[128104, 127999, 8205, 127908], + &[128104, 127999, 8205, 127912], + &[128104, 127999, 8205, 127979], + &[128104, 127999, 8205, 127981], + &[128104, 127999, 8205, 128187], + &[128104, 127999, 8205, 128188], + &[128104, 127999, 8205, 128295], + &[128104, 127999, 8205, 128300], + &[128104, 127999, 8205, 128640], + &[128104, 127999, 8205, 128658], + &[128104, 127999, 8205, 129455], + &[128104, 127999, 8205, 129455, 8205, 10145, 65039], + &[128104, 127999, 8205, 129468], + &[128104, 127999, 8205, 129468, 8205, 10145, 65039], + &[128104, 127999, 8205, 129469], + &[128104, 127999, 8205, 129469, 8205, 10145, 65039], + &[128105, 8205, 9877, 65039], + &[128105, 8205, 9878, 65039], + &[128105, 8205, 9992, 65039], + &[128105, 8205, 127806], + &[128105, 8205, 127859], + &[128105, 8205, 127868], + &[128105, 8205, 127891], + &[128105, 8205, 127908], + &[128105, 8205, 127912], + &[128105, 8205, 127979], + &[128105, 8205, 127981], + &[128105, 8205, 128187], + &[128105, 8205, 128188], + &[128105, 8205, 128295], + &[128105, 8205, 128300], + &[128105, 8205, 128640], + &[128105, 8205, 128658], + &[128105, 8205, 129455], + &[128105, 8205, 129455, 8205, 10145, 65039], + &[128105, 8205, 129468], + &[128105, 8205, 129468, 8205, 10145, 65039], + &[128105, 8205, 129469], + &[128105, 8205, 129469, 8205, 10145, 65039], + &[128105, 127995, 8205, 9877, 65039], + &[128105, 127995, 8205, 9878, 65039], + &[128105, 127995, 8205, 9992, 65039], + &[128105, 127995, 8205, 127806], + &[128105, 127995, 8205, 127859], + &[128105, 127995, 8205, 127868], + &[128105, 127995, 8205, 127891], + &[128105, 127995, 8205, 127908], + &[128105, 127995, 8205, 127912], + &[128105, 127995, 8205, 127979], + &[128105, 127995, 8205, 127981], + &[128105, 127995, 8205, 128187], + &[128105, 127995, 8205, 128188], + &[128105, 127995, 8205, 128295], + &[128105, 127995, 8205, 128300], + &[128105, 127995, 8205, 128640], + &[128105, 127995, 8205, 128658], + &[128105, 127995, 8205, 129455], + &[128105, 127995, 8205, 129455, 8205, 10145, 65039], + &[128105, 127995, 8205, 129468], + &[128105, 127995, 8205, 129468, 8205, 10145, 65039], + &[128105, 127995, 8205, 129469], + &[128105, 127995, 8205, 129469, 8205, 10145, 65039], + &[128105, 127996, 8205, 9877, 65039], + &[128105, 127996, 8205, 9878, 65039], + &[128105, 127996, 8205, 9992, 65039], + &[128105, 127996, 8205, 127806], + &[128105, 127996, 8205, 127859], + &[128105, 127996, 8205, 127868], + &[128105, 127996, 8205, 127891], + &[128105, 127996, 8205, 127908], + &[128105, 127996, 8205, 127912], + &[128105, 127996, 8205, 127979], + &[128105, 127996, 8205, 127981], + &[128105, 127996, 8205, 128187], + &[128105, 127996, 8205, 128188], + &[128105, 127996, 8205, 128295], + &[128105, 127996, 8205, 128300], + &[128105, 127996, 8205, 128640], + &[128105, 127996, 8205, 128658], + &[128105, 127996, 8205, 129455], + &[128105, 127996, 8205, 129455, 8205, 10145, 65039], + &[128105, 127996, 8205, 129468], + &[128105, 127996, 8205, 129468, 8205, 10145, 65039], + &[128105, 127996, 8205, 129469], + &[128105, 127996, 8205, 129469, 8205, 10145, 65039], + &[128105, 127997, 8205, 9877, 65039], + &[128105, 127997, 8205, 9878, 65039], + &[128105, 127997, 8205, 9992, 65039], + &[128105, 127997, 8205, 127806], + &[128105, 127997, 8205, 127859], + &[128105, 127997, 8205, 127868], + &[128105, 127997, 8205, 127891], + &[128105, 127997, 8205, 127908], + &[128105, 127997, 8205, 127912], + &[128105, 127997, 8205, 127979], + &[128105, 127997, 8205, 127981], + &[128105, 127997, 8205, 128187], + &[128105, 127997, 8205, 128188], + &[128105, 127997, 8205, 128295], + &[128105, 127997, 8205, 128300], + &[128105, 127997, 8205, 128640], + &[128105, 127997, 8205, 128658], + &[128105, 127997, 8205, 129455], + &[128105, 127997, 8205, 129455, 8205, 10145, 65039], + &[128105, 127997, 8205, 129468], + &[128105, 127997, 8205, 129468, 8205, 10145, 65039], + &[128105, 127997, 8205, 129469], + &[128105, 127997, 8205, 129469, 8205, 10145, 65039], + &[128105, 127998, 8205, 9877, 65039], + &[128105, 127998, 8205, 9878, 65039], + &[128105, 127998, 8205, 9992, 65039], + &[128105, 127998, 8205, 127806], + &[128105, 127998, 8205, 127859], + &[128105, 127998, 8205, 127868], + &[128105, 127998, 8205, 127891], + &[128105, 127998, 8205, 127908], + &[128105, 127998, 8205, 127912], + &[128105, 127998, 8205, 127979], + &[128105, 127998, 8205, 127981], + &[128105, 127998, 8205, 128187], + &[128105, 127998, 8205, 128188], + &[128105, 127998, 8205, 128295], + &[128105, 127998, 8205, 128300], + &[128105, 127998, 8205, 128640], + &[128105, 127998, 8205, 128658], + &[128105, 127998, 8205, 129455], + &[128105, 127998, 8205, 129455, 8205, 10145, 65039], + &[128105, 127998, 8205, 129468], + &[128105, 127998, 8205, 129468, 8205, 10145, 65039], + &[128105, 127998, 8205, 129469], + &[128105, 127998, 8205, 129469, 8205, 10145, 65039], + &[128105, 127999, 8205, 9877, 65039], + &[128105, 127999, 8205, 9878, 65039], + &[128105, 127999, 8205, 9992, 65039], + &[128105, 127999, 8205, 127806], + &[128105, 127999, 8205, 127859], + &[128105, 127999, 8205, 127868], + &[128105, 127999, 8205, 127891], + &[128105, 127999, 8205, 127908], + &[128105, 127999, 8205, 127912], + &[128105, 127999, 8205, 127979], + &[128105, 127999, 8205, 127981], + &[128105, 127999, 8205, 128187], + &[128105, 127999, 8205, 128188], + &[128105, 127999, 8205, 128295], + &[128105, 127999, 8205, 128300], + &[128105, 127999, 8205, 128640], + &[128105, 127999, 8205, 128658], + &[128105, 127999, 8205, 129455], + &[128105, 127999, 8205, 129455, 8205, 10145, 65039], + &[128105, 127999, 8205, 129468], + &[128105, 127999, 8205, 129468, 8205, 10145, 65039], + &[128105, 127999, 8205, 129469], + &[128105, 127999, 8205, 129469, 8205, 10145, 65039], + &[128694, 8205, 10145, 65039], + &[128694, 127995, 8205, 10145, 65039], + &[128694, 127996, 8205, 10145, 65039], + &[128694, 127997, 8205, 10145, 65039], + &[128694, 127998, 8205, 10145, 65039], + &[128694, 127999, 8205, 10145, 65039], + &[129486, 8205, 10145, 65039], + &[129486, 127995, 8205, 10145, 65039], + &[129486, 127996, 8205, 10145, 65039], + &[129486, 127997, 8205, 10145, 65039], + &[129486, 127998, 8205, 10145, 65039], + &[129486, 127999, 8205, 10145, 65039], + &[129489, 8205, 9877, 65039], + &[129489, 8205, 9878, 65039], + &[129489, 8205, 9992, 65039], + &[129489, 8205, 127806], + &[129489, 8205, 127859], + &[129489, 8205, 127868], + &[129489, 8205, 127876], + &[129489, 8205, 127891], + &[129489, 8205, 127908], + &[129489, 8205, 127912], + &[129489, 8205, 127979], + &[129489, 8205, 127981], + &[129489, 8205, 128187], + &[129489, 8205, 128188], + &[129489, 8205, 128295], + &[129489, 8205, 128300], + &[129489, 8205, 128640], + &[129489, 8205, 128658], + &[129489, 8205, 129455], + &[129489, 8205, 129455, 8205, 10145, 65039], + &[129489, 8205, 129468], + &[129489, 8205, 129468, 8205, 10145, 65039], + &[129489, 8205, 129469], + &[129489, 8205, 129469, 8205, 10145, 65039], + &[129489, 127995, 8205, 9877, 65039], + &[129489, 127995, 8205, 9878, 65039], + &[129489, 127995, 8205, 9992, 65039], + &[129489, 127995, 8205, 127806], + &[129489, 127995, 8205, 127859], + &[129489, 127995, 8205, 127868], + &[129489, 127995, 8205, 127876], + &[129489, 127995, 8205, 127891], + &[129489, 127995, 8205, 127908], + &[129489, 127995, 8205, 127912], + &[129489, 127995, 8205, 127979], + &[129489, 127995, 8205, 127981], + &[129489, 127995, 8205, 128187], + &[129489, 127995, 8205, 128188], + &[129489, 127995, 8205, 128295], + &[129489, 127995, 8205, 128300], + &[129489, 127995, 8205, 128640], + &[129489, 127995, 8205, 128658], + &[129489, 127995, 8205, 129455], + &[129489, 127995, 8205, 129455, 8205, 10145, 65039], + &[129489, 127995, 8205, 129468], + &[129489, 127995, 8205, 129468, 8205, 10145, 65039], + &[129489, 127995, 8205, 129469], + &[129489, 127995, 8205, 129469, 8205, 10145, 65039], + &[129489, 127996, 8205, 9877, 65039], + &[129489, 127996, 8205, 9878, 65039], + &[129489, 127996, 8205, 9992, 65039], + &[129489, 127996, 8205, 127806], + &[129489, 127996, 8205, 127859], + &[129489, 127996, 8205, 127868], + &[129489, 127996, 8205, 127876], + &[129489, 127996, 8205, 127891], + &[129489, 127996, 8205, 127908], + &[129489, 127996, 8205, 127912], + &[129489, 127996, 8205, 127979], + &[129489, 127996, 8205, 127981], + &[129489, 127996, 8205, 128187], + &[129489, 127996, 8205, 128188], + &[129489, 127996, 8205, 128295], + &[129489, 127996, 8205, 128300], + &[129489, 127996, 8205, 128640], + &[129489, 127996, 8205, 128658], + &[129489, 127996, 8205, 129455], + &[129489, 127996, 8205, 129455, 8205, 10145, 65039], + &[129489, 127996, 8205, 129468], + &[129489, 127996, 8205, 129468, 8205, 10145, 65039], + &[129489, 127996, 8205, 129469], + &[129489, 127996, 8205, 129469, 8205, 10145, 65039], + &[129489, 127997, 8205, 9877, 65039], + &[129489, 127997, 8205, 9878, 65039], + &[129489, 127997, 8205, 9992, 65039], + &[129489, 127997, 8205, 127806], + &[129489, 127997, 8205, 127859], + &[129489, 127997, 8205, 127868], + &[129489, 127997, 8205, 127876], + &[129489, 127997, 8205, 127891], + &[129489, 127997, 8205, 127908], + &[129489, 127997, 8205, 127912], + &[129489, 127997, 8205, 127979], + &[129489, 127997, 8205, 127981], + &[129489, 127997, 8205, 128187], + &[129489, 127997, 8205, 128188], + &[129489, 127997, 8205, 128295], + &[129489, 127997, 8205, 128300], + &[129489, 127997, 8205, 128640], + &[129489, 127997, 8205, 128658], + &[129489, 127997, 8205, 129455], + &[129489, 127997, 8205, 129455, 8205, 10145, 65039], + &[129489, 127997, 8205, 129468], + &[129489, 127997, 8205, 129468, 8205, 10145, 65039], + &[129489, 127997, 8205, 129469], + &[129489, 127997, 8205, 129469, 8205, 10145, 65039], + &[129489, 127998, 8205, 9877, 65039], + &[129489, 127998, 8205, 9878, 65039], + &[129489, 127998, 8205, 9992, 65039], + &[129489, 127998, 8205, 127806], + &[129489, 127998, 8205, 127859], + &[129489, 127998, 8205, 127868], + &[129489, 127998, 8205, 127876], + &[129489, 127998, 8205, 127891], + &[129489, 127998, 8205, 127908], + &[129489, 127998, 8205, 127912], + &[129489, 127998, 8205, 127979], + &[129489, 127998, 8205, 127981], + &[129489, 127998, 8205, 128187], + &[129489, 127998, 8205, 128188], + &[129489, 127998, 8205, 128295], + &[129489, 127998, 8205, 128300], + &[129489, 127998, 8205, 128640], + &[129489, 127998, 8205, 128658], + &[129489, 127998, 8205, 129455], + &[129489, 127998, 8205, 129455, 8205, 10145, 65039], + &[129489, 127998, 8205, 129468], + &[129489, 127998, 8205, 129468, 8205, 10145, 65039], + &[129489, 127998, 8205, 129469], + &[129489, 127998, 8205, 129469, 8205, 10145, 65039], + &[129489, 127999, 8205, 9877, 65039], + &[129489, 127999, 8205, 9878, 65039], + &[129489, 127999, 8205, 9992, 65039], + &[129489, 127999, 8205, 127806], + &[129489, 127999, 8205, 127859], + &[129489, 127999, 8205, 127868], + &[129489, 127999, 8205, 127876], + &[129489, 127999, 8205, 127891], + &[129489, 127999, 8205, 127908], + &[129489, 127999, 8205, 127912], + &[129489, 127999, 8205, 127979], + &[129489, 127999, 8205, 127981], + &[129489, 127999, 8205, 128187], + &[129489, 127999, 8205, 128188], + &[129489, 127999, 8205, 128295], + &[129489, 127999, 8205, 128300], + &[129489, 127999, 8205, 128640], + &[129489, 127999, 8205, 128658], + &[129489, 127999, 8205, 129455], + &[129489, 127999, 8205, 129455, 8205, 10145, 65039], + &[129489, 127999, 8205, 129468], + &[129489, 127999, 8205, 129468, 8205, 10145, 65039], + &[129489, 127999, 8205, 129469], + &[129489, 127999, 8205, 129469, 8205, 10145, 65039], + &[9977, 127995, 8205, 9792, 65039], + &[9977, 127995, 8205, 9794, 65039], + &[9977, 127996, 8205, 9792, 65039], + &[9977, 127996, 8205, 9794, 65039], + &[9977, 127997, 8205, 9792, 65039], + &[9977, 127997, 8205, 9794, 65039], + &[9977, 127998, 8205, 9792, 65039], + &[9977, 127998, 8205, 9794, 65039], + &[9977, 127999, 8205, 9792, 65039], + &[9977, 127999, 8205, 9794, 65039], + &[9977, 65039, 8205, 9792, 65039], + &[9977, 65039, 8205, 9794, 65039], + &[127939, 8205, 9792, 65039], + &[127939, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 8205, 9794, 65039], + &[127939, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127995, 8205, 9792, 65039], + &[127939, 127995, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127995, 8205, 9794, 65039], + &[127939, 127995, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127996, 8205, 9792, 65039], + &[127939, 127996, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127996, 8205, 9794, 65039], + &[127939, 127996, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127997, 8205, 9792, 65039], + &[127939, 127997, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127997, 8205, 9794, 65039], + &[127939, 127997, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127998, 8205, 9792, 65039], + &[127939, 127998, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127998, 8205, 9794, 65039], + &[127939, 127998, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127999, 8205, 9792, 65039], + &[127939, 127999, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127999, 8205, 9794, 65039], + &[127939, 127999, 8205, 9794, 65039, 8205, 10145, 65039], + &[127940, 8205, 9792, 65039], + &[127940, 8205, 9794, 65039], + &[127940, 127995, 8205, 9792, 65039], + &[127940, 127995, 8205, 9794, 65039], + &[127940, 127996, 8205, 9792, 65039], + &[127940, 127996, 8205, 9794, 65039], + &[127940, 127997, 8205, 9792, 65039], + &[127940, 127997, 8205, 9794, 65039], + &[127940, 127998, 8205, 9792, 65039], + &[127940, 127998, 8205, 9794, 65039], + &[127940, 127999, 8205, 9792, 65039], + &[127940, 127999, 8205, 9794, 65039], + &[127946, 8205, 9792, 65039], + &[127946, 8205, 9794, 65039], + &[127946, 127995, 8205, 9792, 65039], + &[127946, 127995, 8205, 9794, 65039], + &[127946, 127996, 8205, 9792, 65039], + &[127946, 127996, 8205, 9794, 65039], + &[127946, 127997, 8205, 9792, 65039], + &[127946, 127997, 8205, 9794, 65039], + &[127946, 127998, 8205, 9792, 65039], + &[127946, 127998, 8205, 9794, 65039], + &[127946, 127999, 8205, 9792, 65039], + &[127946, 127999, 8205, 9794, 65039], + &[127947, 127995, 8205, 9792, 65039], + &[127947, 127995, 8205, 9794, 65039], + &[127947, 127996, 8205, 9792, 65039], + &[127947, 127996, 8205, 9794, 65039], + &[127947, 127997, 8205, 9792, 65039], + &[127947, 127997, 8205, 9794, 65039], + &[127947, 127998, 8205, 9792, 65039], + &[127947, 127998, 8205, 9794, 65039], + &[127947, 127999, 8205, 9792, 65039], + &[127947, 127999, 8205, 9794, 65039], + &[127947, 65039, 8205, 9792, 65039], + &[127947, 65039, 8205, 9794, 65039], + &[127948, 127995, 8205, 9792, 65039], + &[127948, 127995, 8205, 9794, 65039], + &[127948, 127996, 8205, 9792, 65039], + &[127948, 127996, 8205, 9794, 65039], + &[127948, 127997, 8205, 9792, 65039], + &[127948, 127997, 8205, 9794, 65039], + &[127948, 127998, 8205, 9792, 65039], + &[127948, 127998, 8205, 9794, 65039], + &[127948, 127999, 8205, 9792, 65039], + &[127948, 127999, 8205, 9794, 65039], + &[127948, 65039, 8205, 9792, 65039], + &[127948, 65039, 8205, 9794, 65039], + &[128110, 8205, 9792, 65039], + &[128110, 8205, 9794, 65039], + &[128110, 127995, 8205, 9792, 65039], + &[128110, 127995, 8205, 9794, 65039], + &[128110, 127996, 8205, 9792, 65039], + &[128110, 127996, 8205, 9794, 65039], + &[128110, 127997, 8205, 9792, 65039], + &[128110, 127997, 8205, 9794, 65039], + &[128110, 127998, 8205, 9792, 65039], + &[128110, 127998, 8205, 9794, 65039], + &[128110, 127999, 8205, 9792, 65039], + &[128110, 127999, 8205, 9794, 65039], + &[128111, 8205, 9792, 65039], + &[128111, 8205, 9794, 65039], + &[128111, 127995, 8205, 9792, 65039], + &[128111, 127995, 8205, 9794, 65039], + &[128111, 127996, 8205, 9792, 65039], + &[128111, 127996, 8205, 9794, 65039], + &[128111, 127997, 8205, 9792, 65039], + &[128111, 127997, 8205, 9794, 65039], + &[128111, 127998, 8205, 9792, 65039], + &[128111, 127998, 8205, 9794, 65039], + &[128111, 127999, 8205, 9792, 65039], + &[128111, 127999, 8205, 9794, 65039], + &[128112, 8205, 9792, 65039], + &[128112, 8205, 9794, 65039], + &[128112, 127995, 8205, 9792, 65039], + &[128112, 127995, 8205, 9794, 65039], + &[128112, 127996, 8205, 9792, 65039], + &[128112, 127996, 8205, 9794, 65039], + &[128112, 127997, 8205, 9792, 65039], + &[128112, 127997, 8205, 9794, 65039], + &[128112, 127998, 8205, 9792, 65039], + &[128112, 127998, 8205, 9794, 65039], + &[128112, 127999, 8205, 9792, 65039], + &[128112, 127999, 8205, 9794, 65039], + &[128113, 8205, 9792, 65039], + &[128113, 8205, 9794, 65039], + &[128113, 127995, 8205, 9792, 65039], + &[128113, 127995, 8205, 9794, 65039], + &[128113, 127996, 8205, 9792, 65039], + &[128113, 127996, 8205, 9794, 65039], + &[128113, 127997, 8205, 9792, 65039], + &[128113, 127997, 8205, 9794, 65039], + &[128113, 127998, 8205, 9792, 65039], + &[128113, 127998, 8205, 9794, 65039], + &[128113, 127999, 8205, 9792, 65039], + &[128113, 127999, 8205, 9794, 65039], + &[128115, 8205, 9792, 65039], + &[128115, 8205, 9794, 65039], + &[128115, 127995, 8205, 9792, 65039], + &[128115, 127995, 8205, 9794, 65039], + &[128115, 127996, 8205, 9792, 65039], + &[128115, 127996, 8205, 9794, 65039], + &[128115, 127997, 8205, 9792, 65039], + &[128115, 127997, 8205, 9794, 65039], + &[128115, 127998, 8205, 9792, 65039], + &[128115, 127998, 8205, 9794, 65039], + &[128115, 127999, 8205, 9792, 65039], + &[128115, 127999, 8205, 9794, 65039], + &[128119, 8205, 9792, 65039], + &[128119, 8205, 9794, 65039], + &[128119, 127995, 8205, 9792, 65039], + &[128119, 127995, 8205, 9794, 65039], + &[128119, 127996, 8205, 9792, 65039], + &[128119, 127996, 8205, 9794, 65039], + &[128119, 127997, 8205, 9792, 65039], + &[128119, 127997, 8205, 9794, 65039], + &[128119, 127998, 8205, 9792, 65039], + &[128119, 127998, 8205, 9794, 65039], + &[128119, 127999, 8205, 9792, 65039], + &[128119, 127999, 8205, 9794, 65039], + &[128129, 8205, 9792, 65039], + &[128129, 8205, 9794, 65039], + &[128129, 127995, 8205, 9792, 65039], + &[128129, 127995, 8205, 9794, 65039], + &[128129, 127996, 8205, 9792, 65039], + &[128129, 127996, 8205, 9794, 65039], + &[128129, 127997, 8205, 9792, 65039], + &[128129, 127997, 8205, 9794, 65039], + &[128129, 127998, 8205, 9792, 65039], + &[128129, 127998, 8205, 9794, 65039], + &[128129, 127999, 8205, 9792, 65039], + &[128129, 127999, 8205, 9794, 65039], + &[128130, 8205, 9792, 65039], + &[128130, 8205, 9794, 65039], + &[128130, 127995, 8205, 9792, 65039], + &[128130, 127995, 8205, 9794, 65039], + &[128130, 127996, 8205, 9792, 65039], + &[128130, 127996, 8205, 9794, 65039], + &[128130, 127997, 8205, 9792, 65039], + &[128130, 127997, 8205, 9794, 65039], + &[128130, 127998, 8205, 9792, 65039], + &[128130, 127998, 8205, 9794, 65039], + &[128130, 127999, 8205, 9792, 65039], + &[128130, 127999, 8205, 9794, 65039], + &[128134, 8205, 9792, 65039], + &[128134, 8205, 9794, 65039], + &[128134, 127995, 8205, 9792, 65039], + &[128134, 127995, 8205, 9794, 65039], + &[128134, 127996, 8205, 9792, 65039], + &[128134, 127996, 8205, 9794, 65039], + &[128134, 127997, 8205, 9792, 65039], + &[128134, 127997, 8205, 9794, 65039], + &[128134, 127998, 8205, 9792, 65039], + &[128134, 127998, 8205, 9794, 65039], + &[128134, 127999, 8205, 9792, 65039], + &[128134, 127999, 8205, 9794, 65039], + &[128135, 8205, 9792, 65039], + &[128135, 8205, 9794, 65039], + &[128135, 127995, 8205, 9792, 65039], + &[128135, 127995, 8205, 9794, 65039], + &[128135, 127996, 8205, 9792, 65039], + &[128135, 127996, 8205, 9794, 65039], + &[128135, 127997, 8205, 9792, 65039], + &[128135, 127997, 8205, 9794, 65039], + &[128135, 127998, 8205, 9792, 65039], + &[128135, 127998, 8205, 9794, 65039], + &[128135, 127999, 8205, 9792, 65039], + &[128135, 127999, 8205, 9794, 65039], + &[128373, 127995, 8205, 9792, 65039], + &[128373, 127995, 8205, 9794, 65039], + &[128373, 127996, 8205, 9792, 65039], + &[128373, 127996, 8205, 9794, 65039], + &[128373, 127997, 8205, 9792, 65039], + &[128373, 127997, 8205, 9794, 65039], + &[128373, 127998, 8205, 9792, 65039], + &[128373, 127998, 8205, 9794, 65039], + &[128373, 127999, 8205, 9792, 65039], + &[128373, 127999, 8205, 9794, 65039], + &[128373, 65039, 8205, 9792, 65039], + &[128373, 65039, 8205, 9794, 65039], + &[128581, 8205, 9792, 65039], + &[128581, 8205, 9794, 65039], + &[128581, 127995, 8205, 9792, 65039], + &[128581, 127995, 8205, 9794, 65039], + &[128581, 127996, 8205, 9792, 65039], + &[128581, 127996, 8205, 9794, 65039], + &[128581, 127997, 8205, 9792, 65039], + &[128581, 127997, 8205, 9794, 65039], + &[128581, 127998, 8205, 9792, 65039], + &[128581, 127998, 8205, 9794, 65039], + &[128581, 127999, 8205, 9792, 65039], + &[128581, 127999, 8205, 9794, 65039], + &[128582, 8205, 9792, 65039], + &[128582, 8205, 9794, 65039], + &[128582, 127995, 8205, 9792, 65039], + &[128582, 127995, 8205, 9794, 65039], + &[128582, 127996, 8205, 9792, 65039], + &[128582, 127996, 8205, 9794, 65039], + &[128582, 127997, 8205, 9792, 65039], + &[128582, 127997, 8205, 9794, 65039], + &[128582, 127998, 8205, 9792, 65039], + &[128582, 127998, 8205, 9794, 65039], + &[128582, 127999, 8205, 9792, 65039], + &[128582, 127999, 8205, 9794, 65039], + &[128583, 8205, 9792, 65039], + &[128583, 8205, 9794, 65039], + &[128583, 127995, 8205, 9792, 65039], + &[128583, 127995, 8205, 9794, 65039], + &[128583, 127996, 8205, 9792, 65039], + &[128583, 127996, 8205, 9794, 65039], + &[128583, 127997, 8205, 9792, 65039], + &[128583, 127997, 8205, 9794, 65039], + &[128583, 127998, 8205, 9792, 65039], + &[128583, 127998, 8205, 9794, 65039], + &[128583, 127999, 8205, 9792, 65039], + &[128583, 127999, 8205, 9794, 65039], + &[128587, 8205, 9792, 65039], + &[128587, 8205, 9794, 65039], + &[128587, 127995, 8205, 9792, 65039], + &[128587, 127995, 8205, 9794, 65039], + &[128587, 127996, 8205, 9792, 65039], + &[128587, 127996, 8205, 9794, 65039], + &[128587, 127997, 8205, 9792, 65039], + &[128587, 127997, 8205, 9794, 65039], + &[128587, 127998, 8205, 9792, 65039], + &[128587, 127998, 8205, 9794, 65039], + &[128587, 127999, 8205, 9792, 65039], + &[128587, 127999, 8205, 9794, 65039], + &[128589, 8205, 9792, 65039], + &[128589, 8205, 9794, 65039], + &[128589, 127995, 8205, 9792, 65039], + &[128589, 127995, 8205, 9794, 65039], + &[128589, 127996, 8205, 9792, 65039], + &[128589, 127996, 8205, 9794, 65039], + &[128589, 127997, 8205, 9792, 65039], + &[128589, 127997, 8205, 9794, 65039], + &[128589, 127998, 8205, 9792, 65039], + &[128589, 127998, 8205, 9794, 65039], + &[128589, 127999, 8205, 9792, 65039], + &[128589, 127999, 8205, 9794, 65039], + &[128590, 8205, 9792, 65039], + &[128590, 8205, 9794, 65039], + &[128590, 127995, 8205, 9792, 65039], + &[128590, 127995, 8205, 9794, 65039], + &[128590, 127996, 8205, 9792, 65039], + &[128590, 127996, 8205, 9794, 65039], + &[128590, 127997, 8205, 9792, 65039], + &[128590, 127997, 8205, 9794, 65039], + &[128590, 127998, 8205, 9792, 65039], + &[128590, 127998, 8205, 9794, 65039], + &[128590, 127999, 8205, 9792, 65039], + &[128590, 127999, 8205, 9794, 65039], + &[128675, 8205, 9792, 65039], + &[128675, 8205, 9794, 65039], + &[128675, 127995, 8205, 9792, 65039], + &[128675, 127995, 8205, 9794, 65039], + &[128675, 127996, 8205, 9792, 65039], + &[128675, 127996, 8205, 9794, 65039], + &[128675, 127997, 8205, 9792, 65039], + &[128675, 127997, 8205, 9794, 65039], + &[128675, 127998, 8205, 9792, 65039], + &[128675, 127998, 8205, 9794, 65039], + &[128675, 127999, 8205, 9792, 65039], + &[128675, 127999, 8205, 9794, 65039], + &[128692, 8205, 9792, 65039], + &[128692, 8205, 9794, 65039], + &[128692, 127995, 8205, 9792, 65039], + &[128692, 127995, 8205, 9794, 65039], + &[128692, 127996, 8205, 9792, 65039], + &[128692, 127996, 8205, 9794, 65039], + &[128692, 127997, 8205, 9792, 65039], + &[128692, 127997, 8205, 9794, 65039], + &[128692, 127998, 8205, 9792, 65039], + &[128692, 127998, 8205, 9794, 65039], + &[128692, 127999, 8205, 9792, 65039], + &[128692, 127999, 8205, 9794, 65039], + &[128693, 8205, 9792, 65039], + &[128693, 8205, 9794, 65039], + &[128693, 127995, 8205, 9792, 65039], + &[128693, 127995, 8205, 9794, 65039], + &[128693, 127996, 8205, 9792, 65039], + &[128693, 127996, 8205, 9794, 65039], + &[128693, 127997, 8205, 9792, 65039], + &[128693, 127997, 8205, 9794, 65039], + &[128693, 127998, 8205, 9792, 65039], + &[128693, 127998, 8205, 9794, 65039], + &[128693, 127999, 8205, 9792, 65039], + &[128693, 127999, 8205, 9794, 65039], + &[128694, 8205, 9792, 65039], + &[128694, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 8205, 9794, 65039], + &[128694, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127995, 8205, 9792, 65039], + &[128694, 127995, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127995, 8205, 9794, 65039], + &[128694, 127995, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127996, 8205, 9792, 65039], + &[128694, 127996, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127996, 8205, 9794, 65039], + &[128694, 127996, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127997, 8205, 9792, 65039], + &[128694, 127997, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127997, 8205, 9794, 65039], + &[128694, 127997, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127998, 8205, 9792, 65039], + &[128694, 127998, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127998, 8205, 9794, 65039], + &[128694, 127998, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127999, 8205, 9792, 65039], + &[128694, 127999, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127999, 8205, 9794, 65039], + &[128694, 127999, 8205, 9794, 65039, 8205, 10145, 65039], + &[129318, 8205, 9792, 65039], + &[129318, 8205, 9794, 65039], + &[129318, 127995, 8205, 9792, 65039], + &[129318, 127995, 8205, 9794, 65039], + &[129318, 127996, 8205, 9792, 65039], + &[129318, 127996, 8205, 9794, 65039], + &[129318, 127997, 8205, 9792, 65039], + &[129318, 127997, 8205, 9794, 65039], + &[129318, 127998, 8205, 9792, 65039], + &[129318, 127998, 8205, 9794, 65039], + &[129318, 127999, 8205, 9792, 65039], + &[129318, 127999, 8205, 9794, 65039], + &[129333, 8205, 9792, 65039], + &[129333, 8205, 9794, 65039], + &[129333, 127995, 8205, 9792, 65039], + &[129333, 127995, 8205, 9794, 65039], + &[129333, 127996, 8205, 9792, 65039], + &[129333, 127996, 8205, 9794, 65039], + &[129333, 127997, 8205, 9792, 65039], + &[129333, 127997, 8205, 9794, 65039], + &[129333, 127998, 8205, 9792, 65039], + &[129333, 127998, 8205, 9794, 65039], + &[129333, 127999, 8205, 9792, 65039], + &[129333, 127999, 8205, 9794, 65039], + &[129335, 8205, 9792, 65039], + &[129335, 8205, 9794, 65039], + &[129335, 127995, 8205, 9792, 65039], + &[129335, 127995, 8205, 9794, 65039], + &[129335, 127996, 8205, 9792, 65039], + &[129335, 127996, 8205, 9794, 65039], + &[129335, 127997, 8205, 9792, 65039], + &[129335, 127997, 8205, 9794, 65039], + &[129335, 127998, 8205, 9792, 65039], + &[129335, 127998, 8205, 9794, 65039], + &[129335, 127999, 8205, 9792, 65039], + &[129335, 127999, 8205, 9794, 65039], + &[129336, 8205, 9792, 65039], + &[129336, 8205, 9794, 65039], + &[129336, 127995, 8205, 9792, 65039], + &[129336, 127995, 8205, 9794, 65039], + &[129336, 127996, 8205, 9792, 65039], + &[129336, 127996, 8205, 9794, 65039], + &[129336, 127997, 8205, 9792, 65039], + &[129336, 127997, 8205, 9794, 65039], + &[129336, 127998, 8205, 9792, 65039], + &[129336, 127998, 8205, 9794, 65039], + &[129336, 127999, 8205, 9792, 65039], + &[129336, 127999, 8205, 9794, 65039], + &[129337, 8205, 9792, 65039], + &[129337, 8205, 9794, 65039], + &[129337, 127995, 8205, 9792, 65039], + &[129337, 127995, 8205, 9794, 65039], + &[129337, 127996, 8205, 9792, 65039], + &[129337, 127996, 8205, 9794, 65039], + &[129337, 127997, 8205, 9792, 65039], + &[129337, 127997, 8205, 9794, 65039], + &[129337, 127998, 8205, 9792, 65039], + &[129337, 127998, 8205, 9794, 65039], + &[129337, 127999, 8205, 9792, 65039], + &[129337, 127999, 8205, 9794, 65039], + &[129340, 8205, 9792, 65039], + &[129340, 8205, 9794, 65039], + &[129340, 127995, 8205, 9792, 65039], + &[129340, 127995, 8205, 9794, 65039], + &[129340, 127996, 8205, 9792, 65039], + &[129340, 127996, 8205, 9794, 65039], + &[129340, 127997, 8205, 9792, 65039], + &[129340, 127997, 8205, 9794, 65039], + &[129340, 127998, 8205, 9792, 65039], + &[129340, 127998, 8205, 9794, 65039], + &[129340, 127999, 8205, 9792, 65039], + &[129340, 127999, 8205, 9794, 65039], + &[129341, 8205, 9792, 65039], + &[129341, 8205, 9794, 65039], + &[129341, 127995, 8205, 9792, 65039], + &[129341, 127995, 8205, 9794, 65039], + &[129341, 127996, 8205, 9792, 65039], + &[129341, 127996, 8205, 9794, 65039], + &[129341, 127997, 8205, 9792, 65039], + &[129341, 127997, 8205, 9794, 65039], + &[129341, 127998, 8205, 9792, 65039], + &[129341, 127998, 8205, 9794, 65039], + &[129341, 127999, 8205, 9792, 65039], + &[129341, 127999, 8205, 9794, 65039], + &[129342, 8205, 9792, 65039], + &[129342, 8205, 9794, 65039], + &[129342, 127995, 8205, 9792, 65039], + &[129342, 127995, 8205, 9794, 65039], + &[129342, 127996, 8205, 9792, 65039], + &[129342, 127996, 8205, 9794, 65039], + &[129342, 127997, 8205, 9792, 65039], + &[129342, 127997, 8205, 9794, 65039], + &[129342, 127998, 8205, 9792, 65039], + &[129342, 127998, 8205, 9794, 65039], + &[129342, 127999, 8205, 9792, 65039], + &[129342, 127999, 8205, 9794, 65039], + &[129464, 8205, 9792, 65039], + &[129464, 8205, 9794, 65039], + &[129464, 127995, 8205, 9792, 65039], + &[129464, 127995, 8205, 9794, 65039], + &[129464, 127996, 8205, 9792, 65039], + &[129464, 127996, 8205, 9794, 65039], + &[129464, 127997, 8205, 9792, 65039], + &[129464, 127997, 8205, 9794, 65039], + &[129464, 127998, 8205, 9792, 65039], + &[129464, 127998, 8205, 9794, 65039], + &[129464, 127999, 8205, 9792, 65039], + &[129464, 127999, 8205, 9794, 65039], + &[129465, 8205, 9792, 65039], + &[129465, 8205, 9794, 65039], + &[129465, 127995, 8205, 9792, 65039], + &[129465, 127995, 8205, 9794, 65039], + &[129465, 127996, 8205, 9792, 65039], + &[129465, 127996, 8205, 9794, 65039], + &[129465, 127997, 8205, 9792, 65039], + &[129465, 127997, 8205, 9794, 65039], + &[129465, 127998, 8205, 9792, 65039], + &[129465, 127998, 8205, 9794, 65039], + &[129465, 127999, 8205, 9792, 65039], + &[129465, 127999, 8205, 9794, 65039], + &[129485, 8205, 9792, 65039], + &[129485, 8205, 9794, 65039], + &[129485, 127995, 8205, 9792, 65039], + &[129485, 127995, 8205, 9794, 65039], + &[129485, 127996, 8205, 9792, 65039], + &[129485, 127996, 8205, 9794, 65039], + &[129485, 127997, 8205, 9792, 65039], + &[129485, 127997, 8205, 9794, 65039], + &[129485, 127998, 8205, 9792, 65039], + &[129485, 127998, 8205, 9794, 65039], + &[129485, 127999, 8205, 9792, 65039], + &[129485, 127999, 8205, 9794, 65039], + &[129486, 8205, 9792, 65039], + &[129486, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 8205, 9794, 65039], + &[129486, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127995, 8205, 9792, 65039], + &[129486, 127995, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127995, 8205, 9794, 65039], + &[129486, 127995, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127996, 8205, 9792, 65039], + &[129486, 127996, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127996, 8205, 9794, 65039], + &[129486, 127996, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127997, 8205, 9792, 65039], + &[129486, 127997, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127997, 8205, 9794, 65039], + &[129486, 127997, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127998, 8205, 9792, 65039], + &[129486, 127998, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127998, 8205, 9794, 65039], + &[129486, 127998, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127999, 8205, 9792, 65039], + &[129486, 127999, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127999, 8205, 9794, 65039], + &[129486, 127999, 8205, 9794, 65039, 8205, 10145, 65039], + &[129487, 8205, 9792, 65039], + &[129487, 8205, 9794, 65039], + &[129487, 127995, 8205, 9792, 65039], + &[129487, 127995, 8205, 9794, 65039], + &[129487, 127996, 8205, 9792, 65039], + &[129487, 127996, 8205, 9794, 65039], + &[129487, 127997, 8205, 9792, 65039], + &[129487, 127997, 8205, 9794, 65039], + &[129487, 127998, 8205, 9792, 65039], + &[129487, 127998, 8205, 9794, 65039], + &[129487, 127999, 8205, 9792, 65039], + &[129487, 127999, 8205, 9794, 65039], + &[129492, 8205, 9792, 65039], + &[129492, 8205, 9794, 65039], + &[129492, 127995, 8205, 9792, 65039], + &[129492, 127995, 8205, 9794, 65039], + &[129492, 127996, 8205, 9792, 65039], + &[129492, 127996, 8205, 9794, 65039], + &[129492, 127997, 8205, 9792, 65039], + &[129492, 127997, 8205, 9794, 65039], + &[129492, 127998, 8205, 9792, 65039], + &[129492, 127998, 8205, 9794, 65039], + &[129492, 127999, 8205, 9792, 65039], + &[129492, 127999, 8205, 9794, 65039], + &[129494, 8205, 9792, 65039], + &[129494, 8205, 9794, 65039], + &[129494, 127995, 8205, 9792, 65039], + &[129494, 127995, 8205, 9794, 65039], + &[129494, 127996, 8205, 9792, 65039], + &[129494, 127996, 8205, 9794, 65039], + &[129494, 127997, 8205, 9792, 65039], + &[129494, 127997, 8205, 9794, 65039], + &[129494, 127998, 8205, 9792, 65039], + &[129494, 127998, 8205, 9794, 65039], + &[129494, 127999, 8205, 9792, 65039], + &[129494, 127999, 8205, 9794, 65039], + &[129495, 8205, 9792, 65039], + &[129495, 8205, 9794, 65039], + &[129495, 127995, 8205, 9792, 65039], + &[129495, 127995, 8205, 9794, 65039], + &[129495, 127996, 8205, 9792, 65039], + &[129495, 127996, 8205, 9794, 65039], + &[129495, 127997, 8205, 9792, 65039], + &[129495, 127997, 8205, 9794, 65039], + &[129495, 127998, 8205, 9792, 65039], + &[129495, 127998, 8205, 9794, 65039], + &[129495, 127999, 8205, 9792, 65039], + &[129495, 127999, 8205, 9794, 65039], + &[129496, 8205, 9792, 65039], + &[129496, 8205, 9794, 65039], + &[129496, 127995, 8205, 9792, 65039], + &[129496, 127995, 8205, 9794, 65039], + &[129496, 127996, 8205, 9792, 65039], + &[129496, 127996, 8205, 9794, 65039], + &[129496, 127997, 8205, 9792, 65039], + &[129496, 127997, 8205, 9794, 65039], + &[129496, 127998, 8205, 9792, 65039], + &[129496, 127998, 8205, 9794, 65039], + &[129496, 127999, 8205, 9792, 65039], + &[129496, 127999, 8205, 9794, 65039], + &[129497, 8205, 9792, 65039], + &[129497, 8205, 9794, 65039], + &[129497, 127995, 8205, 9792, 65039], + &[129497, 127995, 8205, 9794, 65039], + &[129497, 127996, 8205, 9792, 65039], + &[129497, 127996, 8205, 9794, 65039], + &[129497, 127997, 8205, 9792, 65039], + &[129497, 127997, 8205, 9794, 65039], + &[129497, 127998, 8205, 9792, 65039], + &[129497, 127998, 8205, 9794, 65039], + &[129497, 127999, 8205, 9792, 65039], + &[129497, 127999, 8205, 9794, 65039], + &[129498, 8205, 9792, 65039], + &[129498, 8205, 9794, 65039], + &[129498, 127995, 8205, 9792, 65039], + &[129498, 127995, 8205, 9794, 65039], + &[129498, 127996, 8205, 9792, 65039], + &[129498, 127996, 8205, 9794, 65039], + &[129498, 127997, 8205, 9792, 65039], + &[129498, 127997, 8205, 9794, 65039], + &[129498, 127998, 8205, 9792, 65039], + &[129498, 127998, 8205, 9794, 65039], + &[129498, 127999, 8205, 9792, 65039], + &[129498, 127999, 8205, 9794, 65039], + &[129499, 8205, 9792, 65039], + &[129499, 8205, 9794, 65039], + &[129499, 127995, 8205, 9792, 65039], + &[129499, 127995, 8205, 9794, 65039], + &[129499, 127996, 8205, 9792, 65039], + &[129499, 127996, 8205, 9794, 65039], + &[129499, 127997, 8205, 9792, 65039], + &[129499, 127997, 8205, 9794, 65039], + &[129499, 127998, 8205, 9792, 65039], + &[129499, 127998, 8205, 9794, 65039], + &[129499, 127999, 8205, 9792, 65039], + &[129499, 127999, 8205, 9794, 65039], + &[129500, 8205, 9792, 65039], + &[129500, 8205, 9794, 65039], + &[129500, 127995, 8205, 9792, 65039], + &[129500, 127995, 8205, 9794, 65039], + &[129500, 127996, 8205, 9792, 65039], + &[129500, 127996, 8205, 9794, 65039], + &[129500, 127997, 8205, 9792, 65039], + &[129500, 127997, 8205, 9794, 65039], + &[129500, 127998, 8205, 9792, 65039], + &[129500, 127998, 8205, 9794, 65039], + &[129500, 127999, 8205, 9792, 65039], + &[129500, 127999, 8205, 9794, 65039], + &[129501, 8205, 9792, 65039], + &[129501, 8205, 9794, 65039], + &[129501, 127995, 8205, 9792, 65039], + &[129501, 127995, 8205, 9794, 65039], + &[129501, 127996, 8205, 9792, 65039], + &[129501, 127996, 8205, 9794, 65039], + &[129501, 127997, 8205, 9792, 65039], + &[129501, 127997, 8205, 9794, 65039], + &[129501, 127998, 8205, 9792, 65039], + &[129501, 127998, 8205, 9794, 65039], + &[129501, 127999, 8205, 9792, 65039], + &[129501, 127999, 8205, 9794, 65039], + &[129502, 8205, 9792, 65039], + &[129502, 8205, 9794, 65039], + &[129503, 8205, 9792, 65039], + &[129503, 8205, 9794, 65039], + &[128104, 8205, 129456], + &[128104, 8205, 129457], + &[128104, 8205, 129458], + &[128104, 8205, 129459], + &[128104, 127995, 8205, 129456], + &[128104, 127995, 8205, 129457], + &[128104, 127995, 8205, 129458], + &[128104, 127995, 8205, 129459], + &[128104, 127996, 8205, 129456], + &[128104, 127996, 8205, 129457], + &[128104, 127996, 8205, 129458], + &[128104, 127996, 8205, 129459], + &[128104, 127997, 8205, 129456], + &[128104, 127997, 8205, 129457], + &[128104, 127997, 8205, 129458], + &[128104, 127997, 8205, 129459], + &[128104, 127998, 8205, 129456], + &[128104, 127998, 8205, 129457], + &[128104, 127998, 8205, 129458], + &[128104, 127998, 8205, 129459], + &[128104, 127999, 8205, 129456], + &[128104, 127999, 8205, 129457], + &[128104, 127999, 8205, 129458], + &[128104, 127999, 8205, 129459], + &[128105, 8205, 129456], + &[128105, 8205, 129457], + &[128105, 8205, 129458], + &[128105, 8205, 129459], + &[128105, 127995, 8205, 129456], + &[128105, 127995, 8205, 129457], + &[128105, 127995, 8205, 129458], + &[128105, 127995, 8205, 129459], + &[128105, 127996, 8205, 129456], + &[128105, 127996, 8205, 129457], + &[128105, 127996, 8205, 129458], + &[128105, 127996, 8205, 129459], + &[128105, 127997, 8205, 129456], + &[128105, 127997, 8205, 129457], + &[128105, 127997, 8205, 129458], + &[128105, 127997, 8205, 129459], + &[128105, 127998, 8205, 129456], + &[128105, 127998, 8205, 129457], + &[128105, 127998, 8205, 129458], + &[128105, 127998, 8205, 129459], + &[128105, 127999, 8205, 129456], + &[128105, 127999, 8205, 129457], + &[128105, 127999, 8205, 129458], + &[128105, 127999, 8205, 129459], + &[129489, 8205, 129456], + &[129489, 8205, 129457], + &[129489, 8205, 129458], + &[129489, 8205, 129459], + &[129489, 127995, 8205, 129456], + &[129489, 127995, 8205, 129457], + &[129489, 127995, 8205, 129458], + &[129489, 127995, 8205, 129459], + &[129489, 127996, 8205, 129456], + &[129489, 127996, 8205, 129457], + &[129489, 127996, 8205, 129458], + &[129489, 127996, 8205, 129459], + &[129489, 127997, 8205, 129456], + &[129489, 127997, 8205, 129457], + &[129489, 127997, 8205, 129458], + &[129489, 127997, 8205, 129459], + &[129489, 127998, 8205, 129456], + &[129489, 127998, 8205, 129457], + &[129489, 127998, 8205, 129458], + &[129489, 127998, 8205, 129459], + &[129489, 127999, 8205, 129456], + &[129489, 127999, 8205, 129457], + &[129489, 127999, 8205, 129458], + &[129489, 127999, 8205, 129459], + &[9939, 65039, 8205, 128165], + &[10084, 65039, 8205, 128293], + &[10084, 65039, 8205, 129657], + &[127812, 8205, 129003], + &[127819, 8205, 129001], + &[127987, 65039, 8205, 9895, 65039], + &[127987, 65039, 8205, 127752], + &[127988, 8205, 9760, 65039], + &[128008, 8205, 11035], + &[128021, 8205, 129466], + &[128038, 8205, 11035], + &[128038, 8205, 128293], + &[128059, 8205, 10052, 65039], + &[128065, 65039, 8205, 128488, 65039], + &[128558, 8205, 128168], + &[128565, 8205, 128171], + &[128566, 8205, 127787, 65039], + &[128578, 8205, 8596, 65039], + &[128578, 8205, 8597, 65039], + &[129489, 8205, 129648], + &[129489, 127995, 8205, 128048, 8205, 129489, 127996], + &[129489, 127995, 8205, 128048, 8205, 129489, 127997], + &[129489, 127995, 8205, 128048, 8205, 129489, 127998], + &[129489, 127995, 8205, 128048, 8205, 129489, 127999], + &[129489, 127995, 8205, 129648], + &[129489, 127995, 8205, 129775, 8205, 129489, 127996], + &[129489, 127995, 8205, 129775, 8205, 129489, 127997], + &[129489, 127995, 8205, 129775, 8205, 129489, 127998], + &[129489, 127995, 8205, 129775, 8205, 129489, 127999], + &[129489, 127996, 8205, 128048, 8205, 129489, 127995], + &[129489, 127996, 8205, 128048, 8205, 129489, 127997], + &[129489, 127996, 8205, 128048, 8205, 129489, 127998], + &[129489, 127996, 8205, 128048, 8205, 129489, 127999], + &[129489, 127996, 8205, 129648], + &[129489, 127996, 8205, 129775, 8205, 129489, 127995], + &[129489, 127996, 8205, 129775, 8205, 129489, 127997], + &[129489, 127996, 8205, 129775, 8205, 129489, 127998], + &[129489, 127996, 8205, 129775, 8205, 129489, 127999], + &[129489, 127997, 8205, 128048, 8205, 129489, 127995], + &[129489, 127997, 8205, 128048, 8205, 129489, 127996], + &[129489, 127997, 8205, 128048, 8205, 129489, 127998], + &[129489, 127997, 8205, 128048, 8205, 129489, 127999], + &[129489, 127997, 8205, 129648], + &[129489, 127997, 8205, 129775, 8205, 129489, 127995], + &[129489, 127997, 8205, 129775, 8205, 129489, 127996], + &[129489, 127997, 8205, 129775, 8205, 129489, 127998], + &[129489, 127997, 8205, 129775, 8205, 129489, 127999], + &[129489, 127998, 8205, 128048, 8205, 129489, 127995], + &[129489, 127998, 8205, 128048, 8205, 129489, 127996], + &[129489, 127998, 8205, 128048, 8205, 129489, 127997], + &[129489, 127998, 8205, 128048, 8205, 129489, 127999], + &[129489, 127998, 8205, 129648], + &[129489, 127998, 8205, 129775, 8205, 129489, 127995], + &[129489, 127998, 8205, 129775, 8205, 129489, 127996], + &[129489, 127998, 8205, 129775, 8205, 129489, 127997], + &[129489, 127998, 8205, 129775, 8205, 129489, 127999], + &[129489, 127999, 8205, 128048, 8205, 129489, 127995], + &[129489, 127999, 8205, 128048, 8205, 129489, 127996], + &[129489, 127999, 8205, 128048, 8205, 129489, 127997], + &[129489, 127999, 8205, 128048, 8205, 129489, 127998], + &[129489, 127999, 8205, 129648], + &[129489, 127999, 8205, 129775, 8205, 129489, 127995], + &[129489, 127999, 8205, 129775, 8205, 129489, 127996], + &[129489, 127999, 8205, 129775, 8205, 129489, 127997], + &[129489, 127999, 8205, 129775, 8205, 129489, 127998], +]; + +/// Return the code point ranges of the 'RGI_Emoji_ZWJ_Sequence' Unicode property. +pub(crate) fn rgi_emoji_zwj_sequence_sets() -> &'static [&'static [u32]] { + RGI_EMOJI_ZWJ_SEQUENCE.as_slice() +} + +static RGI_EMOJI: &[&[u32]; 3953] = &[ + &[8986], + &[8987], + &[9193], + &[9194], + &[9195], + &[9196], + &[9200], + &[9203], + &[9725], + &[9726], + &[9748], + &[9749], + &[9800], + &[9801], + &[9802], + &[9803], + &[9804], + &[9805], + &[9806], + &[9807], + &[9808], + &[9809], + &[9810], + &[9811], + &[9855], + &[9875], + &[9889], + &[9898], + &[9899], + &[9917], + &[9918], + &[9924], + &[9925], + &[9934], + &[9940], + &[9962], + &[9970], + &[9971], + &[9973], + &[9978], + &[9981], + &[9989], + &[9994], + &[9995], + &[10024], + &[10060], + &[10062], + &[10067], + &[10068], + &[10069], + &[10071], + &[10133], + &[10134], + &[10135], + &[10160], + &[10175], + &[11035], + &[11036], + &[11088], + &[11093], + &[126980], + &[127183], + &[127374], + &[127377], + &[127378], + &[127379], + &[127380], + &[127381], + &[127382], + &[127383], + &[127384], + &[127385], + &[127386], + &[127489], + &[127514], + &[127535], + &[127538], + &[127539], + &[127540], + &[127541], + &[127542], + &[127544], + &[127545], + &[127546], + &[127568], + &[127569], + &[127744], + &[127745], + &[127746], + &[127747], + &[127748], + &[127749], + &[127750], + &[127751], + &[127752], + &[127753], + &[127754], + &[127755], + &[127756], + &[127757], + &[127758], + &[127759], + &[127760], + &[127761], + &[127762], + &[127763], + &[127764], + &[127765], + &[127766], + &[127767], + &[127768], + &[127769], + &[127770], + &[127771], + &[127772], + &[127773], + &[127774], + &[127775], + &[127776], + &[127789], + &[127790], + &[127791], + &[127792], + &[127793], + &[127794], + &[127795], + &[127796], + &[127797], + &[127799], + &[127800], + &[127801], + &[127802], + &[127803], + &[127804], + &[127805], + &[127806], + &[127807], + &[127808], + &[127809], + &[127810], + &[127811], + &[127812], + &[127813], + &[127814], + &[127815], + &[127816], + &[127817], + &[127818], + &[127819], + &[127820], + &[127821], + &[127822], + &[127823], + &[127824], + &[127825], + &[127826], + &[127827], + &[127828], + &[127829], + &[127830], + &[127831], + &[127832], + &[127833], + &[127834], + &[127835], + &[127836], + &[127837], + &[127838], + &[127839], + &[127840], + &[127841], + &[127842], + &[127843], + &[127844], + &[127845], + &[127846], + &[127847], + &[127848], + &[127849], + &[127850], + &[127851], + &[127852], + &[127853], + &[127854], + &[127855], + &[127856], + &[127857], + &[127858], + &[127859], + &[127860], + &[127861], + &[127862], + &[127863], + &[127864], + &[127865], + &[127866], + &[127867], + &[127868], + &[127870], + &[127871], + &[127872], + &[127873], + &[127874], + &[127875], + &[127876], + &[127877], + &[127878], + &[127879], + &[127880], + &[127881], + &[127882], + &[127883], + &[127884], + &[127885], + &[127886], + &[127887], + &[127888], + &[127889], + &[127890], + &[127891], + &[127904], + &[127905], + &[127906], + &[127907], + &[127908], + &[127909], + &[127910], + &[127911], + &[127912], + &[127913], + &[127914], + &[127915], + &[127916], + &[127917], + &[127918], + &[127919], + &[127920], + &[127921], + &[127922], + &[127923], + &[127924], + &[127925], + &[127926], + &[127927], + &[127928], + &[127929], + &[127930], + &[127931], + &[127932], + &[127933], + &[127934], + &[127935], + &[127936], + &[127937], + &[127938], + &[127939], + &[127940], + &[127941], + &[127942], + &[127943], + &[127944], + &[127945], + &[127946], + &[127951], + &[127952], + &[127953], + &[127954], + &[127955], + &[127968], + &[127969], + &[127970], + &[127971], + &[127972], + &[127973], + &[127974], + &[127975], + &[127976], + &[127977], + &[127978], + &[127979], + &[127980], + &[127981], + &[127982], + &[127983], + &[127984], + &[127988], + &[127992], + &[127993], + &[127994], + &[127995], + &[127996], + &[127997], + &[127998], + &[127999], + &[128000], + &[128001], + &[128002], + &[128003], + &[128004], + &[128005], + &[128006], + &[128007], + &[128008], + &[128009], + &[128010], + &[128011], + &[128012], + &[128013], + &[128014], + &[128015], + &[128016], + &[128017], + &[128018], + &[128019], + &[128020], + &[128021], + &[128022], + &[128023], + &[128024], + &[128025], + &[128026], + &[128027], + &[128028], + &[128029], + &[128030], + &[128031], + &[128032], + &[128033], + &[128034], + &[128035], + &[128036], + &[128037], + &[128038], + &[128039], + &[128040], + &[128041], + &[128042], + &[128043], + &[128044], + &[128045], + &[128046], + &[128047], + &[128048], + &[128049], + &[128050], + &[128051], + &[128052], + &[128053], + &[128054], + &[128055], + &[128056], + &[128057], + &[128058], + &[128059], + &[128060], + &[128061], + &[128062], + &[128064], + &[128066], + &[128067], + &[128068], + &[128069], + &[128070], + &[128071], + &[128072], + &[128073], + &[128074], + &[128075], + &[128076], + &[128077], + &[128078], + &[128079], + &[128080], + &[128081], + &[128082], + &[128083], + &[128084], + &[128085], + &[128086], + &[128087], + &[128088], + &[128089], + &[128090], + &[128091], + &[128092], + &[128093], + &[128094], + &[128095], + &[128096], + &[128097], + &[128098], + &[128099], + &[128100], + &[128101], + &[128102], + &[128103], + &[128104], + &[128105], + &[128106], + &[128107], + &[128108], + &[128109], + &[128110], + &[128111], + &[128112], + &[128113], + &[128114], + &[128115], + &[128116], + &[128117], + &[128118], + &[128119], + &[128120], + &[128121], + &[128122], + &[128123], + &[128124], + &[128125], + &[128126], + &[128127], + &[128128], + &[128129], + &[128130], + &[128131], + &[128132], + &[128133], + &[128134], + &[128135], + &[128136], + &[128137], + &[128138], + &[128139], + &[128140], + &[128141], + &[128142], + &[128143], + &[128144], + &[128145], + &[128146], + &[128147], + &[128148], + &[128149], + &[128150], + &[128151], + &[128152], + &[128153], + &[128154], + &[128155], + &[128156], + &[128157], + &[128158], + &[128159], + &[128160], + &[128161], + &[128162], + &[128163], + &[128164], + &[128165], + &[128166], + &[128167], + &[128168], + &[128169], + &[128170], + &[128171], + &[128172], + &[128173], + &[128174], + &[128175], + &[128176], + &[128177], + &[128178], + &[128179], + &[128180], + &[128181], + &[128182], + &[128183], + &[128184], + &[128185], + &[128186], + &[128187], + &[128188], + &[128189], + &[128190], + &[128191], + &[128192], + &[128193], + &[128194], + &[128195], + &[128196], + &[128197], + &[128198], + &[128199], + &[128200], + &[128201], + &[128202], + &[128203], + &[128204], + &[128205], + &[128206], + &[128207], + &[128208], + &[128209], + &[128210], + &[128211], + &[128212], + &[128213], + &[128214], + &[128215], + &[128216], + &[128217], + &[128218], + &[128219], + &[128220], + &[128221], + &[128222], + &[128223], + &[128224], + &[128225], + &[128226], + &[128227], + &[128228], + &[128229], + &[128230], + &[128231], + &[128232], + &[128233], + &[128234], + &[128235], + &[128236], + &[128237], + &[128238], + &[128239], + &[128240], + &[128241], + &[128242], + &[128243], + &[128244], + &[128245], + &[128246], + &[128247], + &[128248], + &[128249], + &[128250], + &[128251], + &[128252], + &[128255], + &[128256], + &[128257], + &[128258], + &[128259], + &[128260], + &[128261], + &[128262], + &[128263], + &[128264], + &[128265], + &[128266], + &[128267], + &[128268], + &[128269], + &[128270], + &[128271], + &[128272], + &[128273], + &[128274], + &[128275], + &[128276], + &[128277], + &[128278], + &[128279], + &[128280], + &[128281], + &[128282], + &[128283], + &[128284], + &[128285], + &[128286], + &[128287], + &[128288], + &[128289], + &[128290], + &[128291], + &[128292], + &[128293], + &[128294], + &[128295], + &[128296], + &[128297], + &[128298], + &[128299], + &[128300], + &[128301], + &[128302], + &[128303], + &[128304], + &[128305], + &[128306], + &[128307], + &[128308], + &[128309], + &[128310], + &[128311], + &[128312], + &[128313], + &[128314], + &[128315], + &[128316], + &[128317], + &[128331], + &[128332], + &[128333], + &[128334], + &[128336], + &[128337], + &[128338], + &[128339], + &[128340], + &[128341], + &[128342], + &[128343], + &[128344], + &[128345], + &[128346], + &[128347], + &[128348], + &[128349], + &[128350], + &[128351], + &[128352], + &[128353], + &[128354], + &[128355], + &[128356], + &[128357], + &[128358], + &[128359], + &[128378], + &[128405], + &[128406], + &[128420], + &[128507], + &[128508], + &[128509], + &[128510], + &[128511], + &[128512], + &[128513], + &[128514], + &[128515], + &[128516], + &[128517], + &[128518], + &[128519], + &[128520], + &[128521], + &[128522], + &[128523], + &[128524], + &[128525], + &[128526], + &[128527], + &[128528], + &[128529], + &[128530], + &[128531], + &[128532], + &[128533], + &[128534], + &[128535], + &[128536], + &[128537], + &[128538], + &[128539], + &[128540], + &[128541], + &[128542], + &[128543], + &[128544], + &[128545], + &[128546], + &[128547], + &[128548], + &[128549], + &[128550], + &[128551], + &[128552], + &[128553], + &[128554], + &[128555], + &[128556], + &[128557], + &[128558], + &[128559], + &[128560], + &[128561], + &[128562], + &[128563], + &[128564], + &[128565], + &[128566], + &[128567], + &[128568], + &[128569], + &[128570], + &[128571], + &[128572], + &[128573], + &[128574], + &[128575], + &[128576], + &[128577], + &[128578], + &[128579], + &[128580], + &[128581], + &[128582], + &[128583], + &[128584], + &[128585], + &[128586], + &[128587], + &[128588], + &[128589], + &[128590], + &[128591], + &[128640], + &[128641], + &[128642], + &[128643], + &[128644], + &[128645], + &[128646], + &[128647], + &[128648], + &[128649], + &[128650], + &[128651], + &[128652], + &[128653], + &[128654], + &[128655], + &[128656], + &[128657], + &[128658], + &[128659], + &[128660], + &[128661], + &[128662], + &[128663], + &[128664], + &[128665], + &[128666], + &[128667], + &[128668], + &[128669], + &[128670], + &[128671], + &[128672], + &[128673], + &[128674], + &[128675], + &[128676], + &[128677], + &[128678], + &[128679], + &[128680], + &[128681], + &[128682], + &[128683], + &[128684], + &[128685], + &[128686], + &[128687], + &[128688], + &[128689], + &[128690], + &[128691], + &[128692], + &[128693], + &[128694], + &[128695], + &[128696], + &[128697], + &[128698], + &[128699], + &[128700], + &[128701], + &[128702], + &[128703], + &[128704], + &[128705], + &[128706], + &[128707], + &[128708], + &[128709], + &[128716], + &[128720], + &[128721], + &[128722], + &[128725], + &[128726], + &[128727], + &[128728], + &[128732], + &[128733], + &[128734], + &[128735], + &[128747], + &[128748], + &[128756], + &[128757], + &[128758], + &[128759], + &[128760], + &[128761], + &[128762], + &[128763], + &[128764], + &[128992], + &[128993], + &[128994], + &[128995], + &[128996], + &[128997], + &[128998], + &[128999], + &[129000], + &[129001], + &[129002], + &[129003], + &[129008], + &[129292], + &[129293], + &[129294], + &[129295], + &[129296], + &[129297], + &[129298], + &[129299], + &[129300], + &[129301], + &[129302], + &[129303], + &[129304], + &[129305], + &[129306], + &[129307], + &[129308], + &[129309], + &[129310], + &[129311], + &[129312], + &[129313], + &[129314], + &[129315], + &[129316], + &[129317], + &[129318], + &[129319], + &[129320], + &[129321], + &[129322], + &[129323], + &[129324], + &[129325], + &[129326], + &[129327], + &[129328], + &[129329], + &[129330], + &[129331], + &[129332], + &[129333], + &[129334], + &[129335], + &[129336], + &[129337], + &[129338], + &[129340], + &[129341], + &[129342], + &[129343], + &[129344], + &[129345], + &[129346], + &[129347], + &[129348], + &[129349], + &[129351], + &[129352], + &[129353], + &[129354], + &[129355], + &[129356], + &[129357], + &[129358], + &[129359], + &[129360], + &[129361], + &[129362], + &[129363], + &[129364], + &[129365], + &[129366], + &[129367], + &[129368], + &[129369], + &[129370], + &[129371], + &[129372], + &[129373], + &[129374], + &[129375], + &[129376], + &[129377], + &[129378], + &[129379], + &[129380], + &[129381], + &[129382], + &[129383], + &[129384], + &[129385], + &[129386], + &[129387], + &[129388], + &[129389], + &[129390], + &[129391], + &[129392], + &[129393], + &[129394], + &[129395], + &[129396], + &[129397], + &[129398], + &[129399], + &[129400], + &[129401], + &[129402], + &[129403], + &[129404], + &[129405], + &[129406], + &[129407], + &[129408], + &[129409], + &[129410], + &[129411], + &[129412], + &[129413], + &[129414], + &[129415], + &[129416], + &[129417], + &[129418], + &[129419], + &[129420], + &[129421], + &[129422], + &[129423], + &[129424], + &[129425], + &[129426], + &[129427], + &[129428], + &[129429], + &[129430], + &[129431], + &[129432], + &[129433], + &[129434], + &[129435], + &[129436], + &[129437], + &[129438], + &[129439], + &[129440], + &[129441], + &[129442], + &[129443], + &[129444], + &[129445], + &[129446], + &[129447], + &[129448], + &[129449], + &[129450], + &[129451], + &[129452], + &[129453], + &[129454], + &[129455], + &[129456], + &[129457], + &[129458], + &[129459], + &[129460], + &[129461], + &[129462], + &[129463], + &[129464], + &[129465], + &[129466], + &[129467], + &[129468], + &[129469], + &[129470], + &[129471], + &[129472], + &[129473], + &[129474], + &[129475], + &[129476], + &[129477], + &[129478], + &[129479], + &[129480], + &[129481], + &[129482], + &[129483], + &[129484], + &[129485], + &[129486], + &[129487], + &[129488], + &[129489], + &[129490], + &[129491], + &[129492], + &[129493], + &[129494], + &[129495], + &[129496], + &[129497], + &[129498], + &[129499], + &[129500], + &[129501], + &[129502], + &[129503], + &[129504], + &[129505], + &[129506], + &[129507], + &[129508], + &[129509], + &[129510], + &[129511], + &[129512], + &[129513], + &[129514], + &[129515], + &[129516], + &[129517], + &[129518], + &[129519], + &[129520], + &[129521], + &[129522], + &[129523], + &[129524], + &[129525], + &[129526], + &[129527], + &[129528], + &[129529], + &[129530], + &[129531], + &[129532], + &[129533], + &[129534], + &[129535], + &[129648], + &[129649], + &[129650], + &[129651], + &[129652], + &[129653], + &[129654], + &[129655], + &[129656], + &[129657], + &[129658], + &[129659], + &[129660], + &[129664], + &[129665], + &[129666], + &[129667], + &[129668], + &[129669], + &[129670], + &[129671], + &[129672], + &[129673], + &[129674], + &[129678], + &[129679], + &[129680], + &[129681], + &[129682], + &[129683], + &[129684], + &[129685], + &[129686], + &[129687], + &[129688], + &[129689], + &[129690], + &[129691], + &[129692], + &[129693], + &[129694], + &[129695], + &[129696], + &[129697], + &[129698], + &[129699], + &[129700], + &[129701], + &[129702], + &[129703], + &[129704], + &[129705], + &[129706], + &[129707], + &[129708], + &[129709], + &[129710], + &[129711], + &[129712], + &[129713], + &[129714], + &[129715], + &[129716], + &[129717], + &[129718], + &[129719], + &[129720], + &[129721], + &[129722], + &[129723], + &[129724], + &[129725], + &[129726], + &[129727], + &[129728], + &[129729], + &[129730], + &[129731], + &[129732], + &[129733], + &[129734], + &[129736], + &[129741], + &[129742], + &[129743], + &[129744], + &[129745], + &[129746], + &[129747], + &[129748], + &[129749], + &[129750], + &[129751], + &[129752], + &[129753], + &[129754], + &[129755], + &[129756], + &[129759], + &[129760], + &[129761], + &[129762], + &[129763], + &[129764], + &[129765], + &[129766], + &[129767], + &[129768], + &[129769], + &[129770], + &[129775], + &[129776], + &[129777], + &[129778], + &[129779], + &[129780], + &[129781], + &[129782], + &[129783], + &[129784], + &[169, 65039], + &[174, 65039], + &[8252, 65039], + &[8265, 65039], + &[8482, 65039], + &[8505, 65039], + &[8596, 65039], + &[8597, 65039], + &[8598, 65039], + &[8599, 65039], + &[8600, 65039], + &[8601, 65039], + &[8617, 65039], + &[8618, 65039], + &[9000, 65039], + &[9167, 65039], + &[9197, 65039], + &[9198, 65039], + &[9199, 65039], + &[9201, 65039], + &[9202, 65039], + &[9208, 65039], + &[9209, 65039], + &[9210, 65039], + &[9410, 65039], + &[9642, 65039], + &[9643, 65039], + &[9654, 65039], + &[9664, 65039], + &[9723, 65039], + &[9724, 65039], + &[9728, 65039], + &[9729, 65039], + &[9730, 65039], + &[9731, 65039], + &[9732, 65039], + &[9742, 65039], + &[9745, 65039], + &[9752, 65039], + &[9757, 65039], + &[9760, 65039], + &[9762, 65039], + &[9763, 65039], + &[9766, 65039], + &[9770, 65039], + &[9774, 65039], + &[9775, 65039], + &[9784, 65039], + &[9785, 65039], + &[9786, 65039], + &[9792, 65039], + &[9794, 65039], + &[9823, 65039], + &[9824, 65039], + &[9827, 65039], + &[9829, 65039], + &[9830, 65039], + &[9832, 65039], + &[9851, 65039], + &[9854, 65039], + &[9874, 65039], + &[9876, 65039], + &[9877, 65039], + &[9878, 65039], + &[9879, 65039], + &[9881, 65039], + &[9883, 65039], + &[9884, 65039], + &[9888, 65039], + &[9895, 65039], + &[9904, 65039], + &[9905, 65039], + &[9928, 65039], + &[9935, 65039], + &[9937, 65039], + &[9939, 65039], + &[9961, 65039], + &[9968, 65039], + &[9969, 65039], + &[9972, 65039], + &[9975, 65039], + &[9976, 65039], + &[9977, 65039], + &[9986, 65039], + &[9992, 65039], + &[9993, 65039], + &[9996, 65039], + &[9997, 65039], + &[9999, 65039], + &[10002, 65039], + &[10004, 65039], + &[10006, 65039], + &[10013, 65039], + &[10017, 65039], + &[10035, 65039], + &[10036, 65039], + &[10052, 65039], + &[10055, 65039], + &[10083, 65039], + &[10084, 65039], + &[10145, 65039], + &[10548, 65039], + &[10549, 65039], + &[11013, 65039], + &[11014, 65039], + &[11015, 65039], + &[12336, 65039], + &[12349, 65039], + &[12951, 65039], + &[12953, 65039], + &[127344, 65039], + &[127345, 65039], + &[127358, 65039], + &[127359, 65039], + &[127490, 65039], + &[127543, 65039], + &[127777, 65039], + &[127780, 65039], + &[127781, 65039], + &[127782, 65039], + &[127783, 65039], + &[127784, 65039], + &[127785, 65039], + &[127786, 65039], + &[127787, 65039], + &[127788, 65039], + &[127798, 65039], + &[127869, 65039], + &[127894, 65039], + &[127895, 65039], + &[127897, 65039], + &[127898, 65039], + &[127899, 65039], + &[127902, 65039], + &[127903, 65039], + &[127947, 65039], + &[127948, 65039], + &[127949, 65039], + &[127950, 65039], + &[127956, 65039], + &[127957, 65039], + &[127958, 65039], + &[127959, 65039], + &[127960, 65039], + &[127961, 65039], + &[127962, 65039], + &[127963, 65039], + &[127964, 65039], + &[127965, 65039], + &[127966, 65039], + &[127967, 65039], + &[127987, 65039], + &[127989, 65039], + &[127991, 65039], + &[128063, 65039], + &[128065, 65039], + &[128253, 65039], + &[128329, 65039], + &[128330, 65039], + &[128367, 65039], + &[128368, 65039], + &[128371, 65039], + &[128372, 65039], + &[128373, 65039], + &[128374, 65039], + &[128375, 65039], + &[128376, 65039], + &[128377, 65039], + &[128391, 65039], + &[128394, 65039], + &[128395, 65039], + &[128396, 65039], + &[128397, 65039], + &[128400, 65039], + &[128421, 65039], + &[128424, 65039], + &[128433, 65039], + &[128434, 65039], + &[128444, 65039], + &[128450, 65039], + &[128451, 65039], + &[128452, 65039], + &[128465, 65039], + &[128466, 65039], + &[128467, 65039], + &[128476, 65039], + &[128477, 65039], + &[128478, 65039], + &[128481, 65039], + &[128483, 65039], + &[128488, 65039], + &[128495, 65039], + &[128499, 65039], + &[128506, 65039], + &[128715, 65039], + &[128717, 65039], + &[128718, 65039], + &[128719, 65039], + &[128736, 65039], + &[128737, 65039], + &[128738, 65039], + &[128739, 65039], + &[128740, 65039], + &[128741, 65039], + &[128745, 65039], + &[128752, 65039], + &[128755, 65039], + &[35, 65039, 8419], + &[42, 65039, 8419], + &[48, 65039, 8419], + &[49, 65039, 8419], + &[50, 65039, 8419], + &[51, 65039, 8419], + &[52, 65039, 8419], + &[53, 65039, 8419], + &[54, 65039, 8419], + &[55, 65039, 8419], + &[56, 65039, 8419], + &[57, 65039, 8419], + &[127462, 127464], + &[127462, 127465], + &[127462, 127466], + &[127462, 127467], + &[127462, 127468], + &[127462, 127470], + &[127462, 127473], + &[127462, 127474], + &[127462, 127476], + &[127462, 127478], + &[127462, 127479], + &[127462, 127480], + &[127462, 127481], + &[127462, 127482], + &[127462, 127484], + &[127462, 127485], + &[127462, 127487], + &[127463, 127462], + &[127463, 127463], + &[127463, 127465], + &[127463, 127466], + &[127463, 127467], + &[127463, 127468], + &[127463, 127469], + &[127463, 127470], + &[127463, 127471], + &[127463, 127473], + &[127463, 127474], + &[127463, 127475], + &[127463, 127476], + &[127463, 127478], + &[127463, 127479], + &[127463, 127480], + &[127463, 127481], + &[127463, 127483], + &[127463, 127484], + &[127463, 127486], + &[127463, 127487], + &[127464, 127462], + &[127464, 127464], + &[127464, 127465], + &[127464, 127467], + &[127464, 127468], + &[127464, 127469], + &[127464, 127470], + &[127464, 127472], + &[127464, 127473], + &[127464, 127474], + &[127464, 127475], + &[127464, 127476], + &[127464, 127477], + &[127464, 127478], + &[127464, 127479], + &[127464, 127482], + &[127464, 127483], + &[127464, 127484], + &[127464, 127485], + &[127464, 127486], + &[127464, 127487], + &[127465, 127466], + &[127465, 127468], + &[127465, 127471], + &[127465, 127472], + &[127465, 127474], + &[127465, 127476], + &[127465, 127487], + &[127466, 127462], + &[127466, 127464], + &[127466, 127466], + &[127466, 127468], + &[127466, 127469], + &[127466, 127479], + &[127466, 127480], + &[127466, 127481], + &[127466, 127482], + &[127467, 127470], + &[127467, 127471], + &[127467, 127472], + &[127467, 127474], + &[127467, 127476], + &[127467, 127479], + &[127468, 127462], + &[127468, 127463], + &[127468, 127465], + &[127468, 127466], + &[127468, 127467], + &[127468, 127468], + &[127468, 127469], + &[127468, 127470], + &[127468, 127473], + &[127468, 127474], + &[127468, 127475], + &[127468, 127477], + &[127468, 127478], + &[127468, 127479], + &[127468, 127480], + &[127468, 127481], + &[127468, 127482], + &[127468, 127484], + &[127468, 127486], + &[127469, 127472], + &[127469, 127474], + &[127469, 127475], + &[127469, 127479], + &[127469, 127481], + &[127469, 127482], + &[127470, 127464], + &[127470, 127465], + &[127470, 127466], + &[127470, 127473], + &[127470, 127474], + &[127470, 127475], + &[127470, 127476], + &[127470, 127478], + &[127470, 127479], + &[127470, 127480], + &[127470, 127481], + &[127471, 127466], + &[127471, 127474], + &[127471, 127476], + &[127471, 127477], + &[127472, 127466], + &[127472, 127468], + &[127472, 127469], + &[127472, 127470], + &[127472, 127474], + &[127472, 127475], + &[127472, 127477], + &[127472, 127479], + &[127472, 127484], + &[127472, 127486], + &[127472, 127487], + &[127473, 127462], + &[127473, 127463], + &[127473, 127464], + &[127473, 127470], + &[127473, 127472], + &[127473, 127479], + &[127473, 127480], + &[127473, 127481], + &[127473, 127482], + &[127473, 127483], + &[127473, 127486], + &[127474, 127462], + &[127474, 127464], + &[127474, 127465], + &[127474, 127466], + &[127474, 127467], + &[127474, 127468], + &[127474, 127469], + &[127474, 127472], + &[127474, 127473], + &[127474, 127474], + &[127474, 127475], + &[127474, 127476], + &[127474, 127477], + &[127474, 127478], + &[127474, 127479], + &[127474, 127480], + &[127474, 127481], + &[127474, 127482], + &[127474, 127483], + &[127474, 127484], + &[127474, 127485], + &[127474, 127486], + &[127474, 127487], + &[127475, 127462], + &[127475, 127464], + &[127475, 127466], + &[127475, 127467], + &[127475, 127468], + &[127475, 127470], + &[127475, 127473], + &[127475, 127476], + &[127475, 127477], + &[127475, 127479], + &[127475, 127482], + &[127475, 127487], + &[127476, 127474], + &[127477, 127462], + &[127477, 127466], + &[127477, 127467], + &[127477, 127468], + &[127477, 127469], + &[127477, 127472], + &[127477, 127473], + &[127477, 127474], + &[127477, 127475], + &[127477, 127479], + &[127477, 127480], + &[127477, 127481], + &[127477, 127484], + &[127477, 127486], + &[127478, 127462], + &[127479, 127466], + &[127479, 127476], + &[127479, 127480], + &[127479, 127482], + &[127479, 127484], + &[127480, 127462], + &[127480, 127463], + &[127480, 127464], + &[127480, 127465], + &[127480, 127466], + &[127480, 127468], + &[127480, 127469], + &[127480, 127470], + &[127480, 127471], + &[127480, 127472], + &[127480, 127473], + &[127480, 127474], + &[127480, 127475], + &[127480, 127476], + &[127480, 127479], + &[127480, 127480], + &[127480, 127481], + &[127480, 127483], + &[127480, 127485], + &[127480, 127486], + &[127480, 127487], + &[127481, 127462], + &[127481, 127464], + &[127481, 127465], + &[127481, 127467], + &[127481, 127468], + &[127481, 127469], + &[127481, 127471], + &[127481, 127472], + &[127481, 127473], + &[127481, 127474], + &[127481, 127475], + &[127481, 127476], + &[127481, 127479], + &[127481, 127481], + &[127481, 127483], + &[127481, 127484], + &[127481, 127487], + &[127482, 127462], + &[127482, 127468], + &[127482, 127474], + &[127482, 127475], + &[127482, 127480], + &[127482, 127486], + &[127482, 127487], + &[127483, 127462], + &[127483, 127464], + &[127483, 127466], + &[127483, 127468], + &[127483, 127470], + &[127483, 127475], + &[127483, 127482], + &[127484, 127467], + &[127484, 127480], + &[127485, 127472], + &[127486, 127466], + &[127486, 127481], + &[127487, 127462], + &[127487, 127474], + &[127487, 127484], + &[9757, 127995], + &[9757, 127996], + &[9757, 127997], + &[9757, 127998], + &[9757, 127999], + &[9977, 127995], + &[9977, 127996], + &[9977, 127997], + &[9977, 127998], + &[9977, 127999], + &[9994, 127995], + &[9994, 127996], + &[9994, 127997], + &[9994, 127998], + &[9994, 127999], + &[9995, 127995], + &[9995, 127996], + &[9995, 127997], + &[9995, 127998], + &[9995, 127999], + &[9996, 127995], + &[9996, 127996], + &[9996, 127997], + &[9996, 127998], + &[9996, 127999], + &[9997, 127995], + &[9997, 127996], + &[9997, 127997], + &[9997, 127998], + &[9997, 127999], + &[127877, 127995], + &[127877, 127996], + &[127877, 127997], + &[127877, 127998], + &[127877, 127999], + &[127938, 127995], + &[127938, 127996], + &[127938, 127997], + &[127938, 127998], + &[127938, 127999], + &[127939, 127995], + &[127939, 127996], + &[127939, 127997], + &[127939, 127998], + &[127939, 127999], + &[127940, 127995], + &[127940, 127996], + &[127940, 127997], + &[127940, 127998], + &[127940, 127999], + &[127943, 127995], + &[127943, 127996], + &[127943, 127997], + &[127943, 127998], + &[127943, 127999], + &[127946, 127995], + &[127946, 127996], + &[127946, 127997], + &[127946, 127998], + &[127946, 127999], + &[127947, 127995], + &[127947, 127996], + &[127947, 127997], + &[127947, 127998], + &[127947, 127999], + &[127948, 127995], + &[127948, 127996], + &[127948, 127997], + &[127948, 127998], + &[127948, 127999], + &[128066, 127995], + &[128066, 127996], + &[128066, 127997], + &[128066, 127998], + &[128066, 127999], + &[128067, 127995], + &[128067, 127996], + &[128067, 127997], + &[128067, 127998], + &[128067, 127999], + &[128070, 127995], + &[128070, 127996], + &[128070, 127997], + &[128070, 127998], + &[128070, 127999], + &[128071, 127995], + &[128071, 127996], + &[128071, 127997], + &[128071, 127998], + &[128071, 127999], + &[128072, 127995], + &[128072, 127996], + &[128072, 127997], + &[128072, 127998], + &[128072, 127999], + &[128073, 127995], + &[128073, 127996], + &[128073, 127997], + &[128073, 127998], + &[128073, 127999], + &[128074, 127995], + &[128074, 127996], + &[128074, 127997], + &[128074, 127998], + &[128074, 127999], + &[128075, 127995], + &[128075, 127996], + &[128075, 127997], + &[128075, 127998], + &[128075, 127999], + &[128076, 127995], + &[128076, 127996], + &[128076, 127997], + &[128076, 127998], + &[128076, 127999], + &[128077, 127995], + &[128077, 127996], + &[128077, 127997], + &[128077, 127998], + &[128077, 127999], + &[128078, 127995], + &[128078, 127996], + &[128078, 127997], + &[128078, 127998], + &[128078, 127999], + &[128079, 127995], + &[128079, 127996], + &[128079, 127997], + &[128079, 127998], + &[128079, 127999], + &[128080, 127995], + &[128080, 127996], + &[128080, 127997], + &[128080, 127998], + &[128080, 127999], + &[128102, 127995], + &[128102, 127996], + &[128102, 127997], + &[128102, 127998], + &[128102, 127999], + &[128103, 127995], + &[128103, 127996], + &[128103, 127997], + &[128103, 127998], + &[128103, 127999], + &[128104, 127995], + &[128104, 127996], + &[128104, 127997], + &[128104, 127998], + &[128104, 127999], + &[128105, 127995], + &[128105, 127996], + &[128105, 127997], + &[128105, 127998], + &[128105, 127999], + &[128107, 127995], + &[128107, 127996], + &[128107, 127997], + &[128107, 127998], + &[128107, 127999], + &[128108, 127995], + &[128108, 127996], + &[128108, 127997], + &[128108, 127998], + &[128108, 127999], + &[128109, 127995], + &[128109, 127996], + &[128109, 127997], + &[128109, 127998], + &[128109, 127999], + &[128110, 127995], + &[128110, 127996], + &[128110, 127997], + &[128110, 127998], + &[128110, 127999], + &[128111, 127995], + &[128111, 127996], + &[128111, 127997], + &[128111, 127998], + &[128111, 127999], + &[128112, 127995], + &[128112, 127996], + &[128112, 127997], + &[128112, 127998], + &[128112, 127999], + &[128113, 127995], + &[128113, 127996], + &[128113, 127997], + &[128113, 127998], + &[128113, 127999], + &[128114, 127995], + &[128114, 127996], + &[128114, 127997], + &[128114, 127998], + &[128114, 127999], + &[128115, 127995], + &[128115, 127996], + &[128115, 127997], + &[128115, 127998], + &[128115, 127999], + &[128116, 127995], + &[128116, 127996], + &[128116, 127997], + &[128116, 127998], + &[128116, 127999], + &[128117, 127995], + &[128117, 127996], + &[128117, 127997], + &[128117, 127998], + &[128117, 127999], + &[128118, 127995], + &[128118, 127996], + &[128118, 127997], + &[128118, 127998], + &[128118, 127999], + &[128119, 127995], + &[128119, 127996], + &[128119, 127997], + &[128119, 127998], + &[128119, 127999], + &[128120, 127995], + &[128120, 127996], + &[128120, 127997], + &[128120, 127998], + &[128120, 127999], + &[128124, 127995], + &[128124, 127996], + &[128124, 127997], + &[128124, 127998], + &[128124, 127999], + &[128129, 127995], + &[128129, 127996], + &[128129, 127997], + &[128129, 127998], + &[128129, 127999], + &[128130, 127995], + &[128130, 127996], + &[128130, 127997], + &[128130, 127998], + &[128130, 127999], + &[128131, 127995], + &[128131, 127996], + &[128131, 127997], + &[128131, 127998], + &[128131, 127999], + &[128133, 127995], + &[128133, 127996], + &[128133, 127997], + &[128133, 127998], + &[128133, 127999], + &[128134, 127995], + &[128134, 127996], + &[128134, 127997], + &[128134, 127998], + &[128134, 127999], + &[128135, 127995], + &[128135, 127996], + &[128135, 127997], + &[128135, 127998], + &[128135, 127999], + &[128143, 127995], + &[128143, 127996], + &[128143, 127997], + &[128143, 127998], + &[128143, 127999], + &[128145, 127995], + &[128145, 127996], + &[128145, 127997], + &[128145, 127998], + &[128145, 127999], + &[128170, 127995], + &[128170, 127996], + &[128170, 127997], + &[128170, 127998], + &[128170, 127999], + &[128372, 127995], + &[128372, 127996], + &[128372, 127997], + &[128372, 127998], + &[128372, 127999], + &[128373, 127995], + &[128373, 127996], + &[128373, 127997], + &[128373, 127998], + &[128373, 127999], + &[128378, 127995], + &[128378, 127996], + &[128378, 127997], + &[128378, 127998], + &[128378, 127999], + &[128400, 127995], + &[128400, 127996], + &[128400, 127997], + &[128400, 127998], + &[128400, 127999], + &[128405, 127995], + &[128405, 127996], + &[128405, 127997], + &[128405, 127998], + &[128405, 127999], + &[128406, 127995], + &[128406, 127996], + &[128406, 127997], + &[128406, 127998], + &[128406, 127999], + &[128581, 127995], + &[128581, 127996], + &[128581, 127997], + &[128581, 127998], + &[128581, 127999], + &[128582, 127995], + &[128582, 127996], + &[128582, 127997], + &[128582, 127998], + &[128582, 127999], + &[128583, 127995], + &[128583, 127996], + &[128583, 127997], + &[128583, 127998], + &[128583, 127999], + &[128587, 127995], + &[128587, 127996], + &[128587, 127997], + &[128587, 127998], + &[128587, 127999], + &[128588, 127995], + &[128588, 127996], + &[128588, 127997], + &[128588, 127998], + &[128588, 127999], + &[128589, 127995], + &[128589, 127996], + &[128589, 127997], + &[128589, 127998], + &[128589, 127999], + &[128590, 127995], + &[128590, 127996], + &[128590, 127997], + &[128590, 127998], + &[128590, 127999], + &[128591, 127995], + &[128591, 127996], + &[128591, 127997], + &[128591, 127998], + &[128591, 127999], + &[128675, 127995], + &[128675, 127996], + &[128675, 127997], + &[128675, 127998], + &[128675, 127999], + &[128692, 127995], + &[128692, 127996], + &[128692, 127997], + &[128692, 127998], + &[128692, 127999], + &[128693, 127995], + &[128693, 127996], + &[128693, 127997], + &[128693, 127998], + &[128693, 127999], + &[128694, 127995], + &[128694, 127996], + &[128694, 127997], + &[128694, 127998], + &[128694, 127999], + &[128704, 127995], + &[128704, 127996], + &[128704, 127997], + &[128704, 127998], + &[128704, 127999], + &[128716, 127995], + &[128716, 127996], + &[128716, 127997], + &[128716, 127998], + &[128716, 127999], + &[129292, 127995], + &[129292, 127996], + &[129292, 127997], + &[129292, 127998], + &[129292, 127999], + &[129295, 127995], + &[129295, 127996], + &[129295, 127997], + &[129295, 127998], + &[129295, 127999], + &[129304, 127995], + &[129304, 127996], + &[129304, 127997], + &[129304, 127998], + &[129304, 127999], + &[129305, 127995], + &[129305, 127996], + &[129305, 127997], + &[129305, 127998], + &[129305, 127999], + &[129306, 127995], + &[129306, 127996], + &[129306, 127997], + &[129306, 127998], + &[129306, 127999], + &[129307, 127995], + &[129307, 127996], + &[129307, 127997], + &[129307, 127998], + &[129307, 127999], + &[129308, 127995], + &[129308, 127996], + &[129308, 127997], + &[129308, 127998], + &[129308, 127999], + &[129309, 127995], + &[129309, 127996], + &[129309, 127997], + &[129309, 127998], + &[129309, 127999], + &[129310, 127995], + &[129310, 127996], + &[129310, 127997], + &[129310, 127998], + &[129310, 127999], + &[129311, 127995], + &[129311, 127996], + &[129311, 127997], + &[129311, 127998], + &[129311, 127999], + &[129318, 127995], + &[129318, 127996], + &[129318, 127997], + &[129318, 127998], + &[129318, 127999], + &[129328, 127995], + &[129328, 127996], + &[129328, 127997], + &[129328, 127998], + &[129328, 127999], + &[129329, 127995], + &[129329, 127996], + &[129329, 127997], + &[129329, 127998], + &[129329, 127999], + &[129330, 127995], + &[129330, 127996], + &[129330, 127997], + &[129330, 127998], + &[129330, 127999], + &[129331, 127995], + &[129331, 127996], + &[129331, 127997], + &[129331, 127998], + &[129331, 127999], + &[129332, 127995], + &[129332, 127996], + &[129332, 127997], + &[129332, 127998], + &[129332, 127999], + &[129333, 127995], + &[129333, 127996], + &[129333, 127997], + &[129333, 127998], + &[129333, 127999], + &[129334, 127995], + &[129334, 127996], + &[129334, 127997], + &[129334, 127998], + &[129334, 127999], + &[129335, 127995], + &[129335, 127996], + &[129335, 127997], + &[129335, 127998], + &[129335, 127999], + &[129336, 127995], + &[129336, 127996], + &[129336, 127997], + &[129336, 127998], + &[129336, 127999], + &[129337, 127995], + &[129337, 127996], + &[129337, 127997], + &[129337, 127998], + &[129337, 127999], + &[129340, 127995], + &[129340, 127996], + &[129340, 127997], + &[129340, 127998], + &[129340, 127999], + &[129341, 127995], + &[129341, 127996], + &[129341, 127997], + &[129341, 127998], + &[129341, 127999], + &[129342, 127995], + &[129342, 127996], + &[129342, 127997], + &[129342, 127998], + &[129342, 127999], + &[129399, 127995], + &[129399, 127996], + &[129399, 127997], + &[129399, 127998], + &[129399, 127999], + &[129461, 127995], + &[129461, 127996], + &[129461, 127997], + &[129461, 127998], + &[129461, 127999], + &[129462, 127995], + &[129462, 127996], + &[129462, 127997], + &[129462, 127998], + &[129462, 127999], + &[129464, 127995], + &[129464, 127996], + &[129464, 127997], + &[129464, 127998], + &[129464, 127999], + &[129465, 127995], + &[129465, 127996], + &[129465, 127997], + &[129465, 127998], + &[129465, 127999], + &[129467, 127995], + &[129467, 127996], + &[129467, 127997], + &[129467, 127998], + &[129467, 127999], + &[129485, 127995], + &[129485, 127996], + &[129485, 127997], + &[129485, 127998], + &[129485, 127999], + &[129486, 127995], + &[129486, 127996], + &[129486, 127997], + &[129486, 127998], + &[129486, 127999], + &[129487, 127995], + &[129487, 127996], + &[129487, 127997], + &[129487, 127998], + &[129487, 127999], + &[129489, 127995], + &[129489, 127996], + &[129489, 127997], + &[129489, 127998], + &[129489, 127999], + &[129490, 127995], + &[129490, 127996], + &[129490, 127997], + &[129490, 127998], + &[129490, 127999], + &[129491, 127995], + &[129491, 127996], + &[129491, 127997], + &[129491, 127998], + &[129491, 127999], + &[129492, 127995], + &[129492, 127996], + &[129492, 127997], + &[129492, 127998], + &[129492, 127999], + &[129493, 127995], + &[129493, 127996], + &[129493, 127997], + &[129493, 127998], + &[129493, 127999], + &[129494, 127995], + &[129494, 127996], + &[129494, 127997], + &[129494, 127998], + &[129494, 127999], + &[129495, 127995], + &[129495, 127996], + &[129495, 127997], + &[129495, 127998], + &[129495, 127999], + &[129496, 127995], + &[129496, 127996], + &[129496, 127997], + &[129496, 127998], + &[129496, 127999], + &[129497, 127995], + &[129497, 127996], + &[129497, 127997], + &[129497, 127998], + &[129497, 127999], + &[129498, 127995], + &[129498, 127996], + &[129498, 127997], + &[129498, 127998], + &[129498, 127999], + &[129499, 127995], + &[129499, 127996], + &[129499, 127997], + &[129499, 127998], + &[129499, 127999], + &[129500, 127995], + &[129500, 127996], + &[129500, 127997], + &[129500, 127998], + &[129500, 127999], + &[129501, 127995], + &[129501, 127996], + &[129501, 127997], + &[129501, 127998], + &[129501, 127999], + &[129731, 127995], + &[129731, 127996], + &[129731, 127997], + &[129731, 127998], + &[129731, 127999], + &[129732, 127995], + &[129732, 127996], + &[129732, 127997], + &[129732, 127998], + &[129732, 127999], + &[129733, 127995], + &[129733, 127996], + &[129733, 127997], + &[129733, 127998], + &[129733, 127999], + &[129776, 127995], + &[129776, 127996], + &[129776, 127997], + &[129776, 127998], + &[129776, 127999], + &[129777, 127995], + &[129777, 127996], + &[129777, 127997], + &[129777, 127998], + &[129777, 127999], + &[129778, 127995], + &[129778, 127996], + &[129778, 127997], + &[129778, 127998], + &[129778, 127999], + &[129779, 127995], + &[129779, 127996], + &[129779, 127997], + &[129779, 127998], + &[129779, 127999], + &[129780, 127995], + &[129780, 127996], + &[129780, 127997], + &[129780, 127998], + &[129780, 127999], + &[129781, 127995], + &[129781, 127996], + &[129781, 127997], + &[129781, 127998], + &[129781, 127999], + &[129782, 127995], + &[129782, 127996], + &[129782, 127997], + &[129782, 127998], + &[129782, 127999], + &[129783, 127995], + &[129783, 127996], + &[129783, 127997], + &[129783, 127998], + &[129783, 127999], + &[129784, 127995], + &[129784, 127996], + &[129784, 127997], + &[129784, 127998], + &[129784, 127999], + &[127988, 917607, 917602, 917605, 917614, 917607, 917631], + &[127988, 917607, 917602, 917619, 917603, 917620, 917631], + &[127988, 917607, 917602, 917623, 917612, 917619, 917631], + &[128104, 8205, 10084, 65039, 8205, 128104], + &[128104, 8205, 10084, 65039, 8205, 128139, 8205, 128104], + &[128104, 8205, 128102], + &[128104, 8205, 128102, 8205, 128102], + &[128104, 8205, 128103], + &[128104, 8205, 128103, 8205, 128102], + &[128104, 8205, 128103, 8205, 128103], + &[128104, 8205, 128104, 8205, 128102], + &[128104, 8205, 128104, 8205, 128102, 8205, 128102], + &[128104, 8205, 128104, 8205, 128103], + &[128104, 8205, 128104, 8205, 128103, 8205, 128102], + &[128104, 8205, 128104, 8205, 128103, 8205, 128103], + &[128104, 8205, 128105, 8205, 128102], + &[128104, 8205, 128105, 8205, 128102, 8205, 128102], + &[128104, 8205, 128105, 8205, 128103], + &[128104, 8205, 128105, 8205, 128103, 8205, 128102], + &[128104, 8205, 128105, 8205, 128103, 8205, 128103], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127995, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127995, 8205, 128048, 8205, 128104, 127996], + &[128104, 127995, 8205, 128048, 8205, 128104, 127997], + &[128104, 127995, 8205, 128048, 8205, 128104, 127998], + &[128104, 127995, 8205, 128048, 8205, 128104, 127999], + &[128104, 127995, 8205, 129309, 8205, 128104, 127996], + &[128104, 127995, 8205, 129309, 8205, 128104, 127997], + &[128104, 127995, 8205, 129309, 8205, 128104, 127998], + &[128104, 127995, 8205, 129309, 8205, 128104, 127999], + &[128104, 127995, 8205, 129775, 8205, 128104, 127996], + &[128104, 127995, 8205, 129775, 8205, 128104, 127997], + &[128104, 127995, 8205, 129775, 8205, 128104, 127998], + &[128104, 127995, 8205, 129775, 8205, 128104, 127999], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127996, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127996, 8205, 128048, 8205, 128104, 127995], + &[128104, 127996, 8205, 128048, 8205, 128104, 127997], + &[128104, 127996, 8205, 128048, 8205, 128104, 127998], + &[128104, 127996, 8205, 128048, 8205, 128104, 127999], + &[128104, 127996, 8205, 129309, 8205, 128104, 127995], + &[128104, 127996, 8205, 129309, 8205, 128104, 127997], + &[128104, 127996, 8205, 129309, 8205, 128104, 127998], + &[128104, 127996, 8205, 129309, 8205, 128104, 127999], + &[128104, 127996, 8205, 129775, 8205, 128104, 127995], + &[128104, 127996, 8205, 129775, 8205, 128104, 127997], + &[128104, 127996, 8205, 129775, 8205, 128104, 127998], + &[128104, 127996, 8205, 129775, 8205, 128104, 127999], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127997, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127997, 8205, 128048, 8205, 128104, 127995], + &[128104, 127997, 8205, 128048, 8205, 128104, 127996], + &[128104, 127997, 8205, 128048, 8205, 128104, 127998], + &[128104, 127997, 8205, 128048, 8205, 128104, 127999], + &[128104, 127997, 8205, 129309, 8205, 128104, 127995], + &[128104, 127997, 8205, 129309, 8205, 128104, 127996], + &[128104, 127997, 8205, 129309, 8205, 128104, 127998], + &[128104, 127997, 8205, 129309, 8205, 128104, 127999], + &[128104, 127997, 8205, 129775, 8205, 128104, 127995], + &[128104, 127997, 8205, 129775, 8205, 128104, 127996], + &[128104, 127997, 8205, 129775, 8205, 128104, 127998], + &[128104, 127997, 8205, 129775, 8205, 128104, 127999], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127998, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127998, 8205, 128048, 8205, 128104, 127995], + &[128104, 127998, 8205, 128048, 8205, 128104, 127996], + &[128104, 127998, 8205, 128048, 8205, 128104, 127997], + &[128104, 127998, 8205, 128048, 8205, 128104, 127999], + &[128104, 127998, 8205, 129309, 8205, 128104, 127995], + &[128104, 127998, 8205, 129309, 8205, 128104, 127996], + &[128104, 127998, 8205, 129309, 8205, 128104, 127997], + &[128104, 127998, 8205, 129309, 8205, 128104, 127999], + &[128104, 127998, 8205, 129775, 8205, 128104, 127995], + &[128104, 127998, 8205, 129775, 8205, 128104, 127996], + &[128104, 127998, 8205, 129775, 8205, 128104, 127997], + &[128104, 127998, 8205, 129775, 8205, 128104, 127999], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127995], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127996], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127997], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127998], + &[128104, 127999, 8205, 10084, 65039, 8205, 128104, 127999], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128104, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[128104, 127999, 8205, 128048, 8205, 128104, 127995], + &[128104, 127999, 8205, 128048, 8205, 128104, 127996], + &[128104, 127999, 8205, 128048, 8205, 128104, 127997], + &[128104, 127999, 8205, 128048, 8205, 128104, 127998], + &[128104, 127999, 8205, 129309, 8205, 128104, 127995], + &[128104, 127999, 8205, 129309, 8205, 128104, 127996], + &[128104, 127999, 8205, 129309, 8205, 128104, 127997], + &[128104, 127999, 8205, 129309, 8205, 128104, 127998], + &[128104, 127999, 8205, 129775, 8205, 128104, 127995], + &[128104, 127999, 8205, 129775, 8205, 128104, 127996], + &[128104, 127999, 8205, 129775, 8205, 128104, 127997], + &[128104, 127999, 8205, 129775, 8205, 128104, 127998], + &[128105, 8205, 10084, 65039, 8205, 128104], + &[128105, 8205, 10084, 65039, 8205, 128105], + &[128105, 8205, 10084, 65039, 8205, 128139, 8205, 128104], + &[128105, 8205, 10084, 65039, 8205, 128139, 8205, 128105], + &[128105, 8205, 128102], + &[128105, 8205, 128102, 8205, 128102], + &[128105, 8205, 128103], + &[128105, 8205, 128103, 8205, 128102], + &[128105, 8205, 128103, 8205, 128103], + &[128105, 8205, 128105, 8205, 128102], + &[128105, 8205, 128105, 8205, 128102, 8205, 128102], + &[128105, 8205, 128105, 8205, 128103], + &[128105, 8205, 128105, 8205, 128103, 8205, 128102], + &[128105, 8205, 128105, 8205, 128103, 8205, 128103], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127995, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127995, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127995, 8205, 128048, 8205, 128105, 127996], + &[128105, 127995, 8205, 128048, 8205, 128105, 127997], + &[128105, 127995, 8205, 128048, 8205, 128105, 127998], + &[128105, 127995, 8205, 128048, 8205, 128105, 127999], + &[128105, 127995, 8205, 129309, 8205, 128104, 127996], + &[128105, 127995, 8205, 129309, 8205, 128104, 127997], + &[128105, 127995, 8205, 129309, 8205, 128104, 127998], + &[128105, 127995, 8205, 129309, 8205, 128104, 127999], + &[128105, 127995, 8205, 129309, 8205, 128105, 127996], + &[128105, 127995, 8205, 129309, 8205, 128105, 127997], + &[128105, 127995, 8205, 129309, 8205, 128105, 127998], + &[128105, 127995, 8205, 129309, 8205, 128105, 127999], + &[128105, 127995, 8205, 129775, 8205, 128105, 127996], + &[128105, 127995, 8205, 129775, 8205, 128105, 127997], + &[128105, 127995, 8205, 129775, 8205, 128105, 127998], + &[128105, 127995, 8205, 129775, 8205, 128105, 127999], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127996, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127996, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127996, 8205, 128048, 8205, 128105, 127995], + &[128105, 127996, 8205, 128048, 8205, 128105, 127997], + &[128105, 127996, 8205, 128048, 8205, 128105, 127998], + &[128105, 127996, 8205, 128048, 8205, 128105, 127999], + &[128105, 127996, 8205, 129309, 8205, 128104, 127995], + &[128105, 127996, 8205, 129309, 8205, 128104, 127997], + &[128105, 127996, 8205, 129309, 8205, 128104, 127998], + &[128105, 127996, 8205, 129309, 8205, 128104, 127999], + &[128105, 127996, 8205, 129309, 8205, 128105, 127995], + &[128105, 127996, 8205, 129309, 8205, 128105, 127997], + &[128105, 127996, 8205, 129309, 8205, 128105, 127998], + &[128105, 127996, 8205, 129309, 8205, 128105, 127999], + &[128105, 127996, 8205, 129775, 8205, 128105, 127995], + &[128105, 127996, 8205, 129775, 8205, 128105, 127997], + &[128105, 127996, 8205, 129775, 8205, 128105, 127998], + &[128105, 127996, 8205, 129775, 8205, 128105, 127999], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127997, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127997, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127997, 8205, 128048, 8205, 128105, 127995], + &[128105, 127997, 8205, 128048, 8205, 128105, 127996], + &[128105, 127997, 8205, 128048, 8205, 128105, 127998], + &[128105, 127997, 8205, 128048, 8205, 128105, 127999], + &[128105, 127997, 8205, 129309, 8205, 128104, 127995], + &[128105, 127997, 8205, 129309, 8205, 128104, 127996], + &[128105, 127997, 8205, 129309, 8205, 128104, 127998], + &[128105, 127997, 8205, 129309, 8205, 128104, 127999], + &[128105, 127997, 8205, 129309, 8205, 128105, 127995], + &[128105, 127997, 8205, 129309, 8205, 128105, 127996], + &[128105, 127997, 8205, 129309, 8205, 128105, 127998], + &[128105, 127997, 8205, 129309, 8205, 128105, 127999], + &[128105, 127997, 8205, 129775, 8205, 128105, 127995], + &[128105, 127997, 8205, 129775, 8205, 128105, 127996], + &[128105, 127997, 8205, 129775, 8205, 128105, 127998], + &[128105, 127997, 8205, 129775, 8205, 128105, 127999], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127998, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127998, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127998, 8205, 128048, 8205, 128105, 127995], + &[128105, 127998, 8205, 128048, 8205, 128105, 127996], + &[128105, 127998, 8205, 128048, 8205, 128105, 127997], + &[128105, 127998, 8205, 128048, 8205, 128105, 127999], + &[128105, 127998, 8205, 129309, 8205, 128104, 127995], + &[128105, 127998, 8205, 129309, 8205, 128104, 127996], + &[128105, 127998, 8205, 129309, 8205, 128104, 127997], + &[128105, 127998, 8205, 129309, 8205, 128104, 127999], + &[128105, 127998, 8205, 129309, 8205, 128105, 127995], + &[128105, 127998, 8205, 129309, 8205, 128105, 127996], + &[128105, 127998, 8205, 129309, 8205, 128105, 127997], + &[128105, 127998, 8205, 129309, 8205, 128105, 127999], + &[128105, 127998, 8205, 129775, 8205, 128105, 127995], + &[128105, 127998, 8205, 129775, 8205, 128105, 127996], + &[128105, 127998, 8205, 129775, 8205, 128105, 127997], + &[128105, 127998, 8205, 129775, 8205, 128105, 127999], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127995], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127996], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127997], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127998], + &[128105, 127999, 8205, 10084, 65039, 8205, 128104, 127999], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127995], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127996], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127997], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127998], + &[128105, 127999, 8205, 10084, 65039, 8205, 128105, 127999], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127995, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127996, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127997, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127998, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128104, 127999, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127995, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127996, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127997, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127998, + ], + &[ + 128105, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 128105, 127999, + ], + &[128105, 127999, 8205, 128048, 8205, 128105, 127995], + &[128105, 127999, 8205, 128048, 8205, 128105, 127996], + &[128105, 127999, 8205, 128048, 8205, 128105, 127997], + &[128105, 127999, 8205, 128048, 8205, 128105, 127998], + &[128105, 127999, 8205, 129309, 8205, 128104, 127995], + &[128105, 127999, 8205, 129309, 8205, 128104, 127996], + &[128105, 127999, 8205, 129309, 8205, 128104, 127997], + &[128105, 127999, 8205, 129309, 8205, 128104, 127998], + &[128105, 127999, 8205, 129309, 8205, 128105, 127995], + &[128105, 127999, 8205, 129309, 8205, 128105, 127996], + &[128105, 127999, 8205, 129309, 8205, 128105, 127997], + &[128105, 127999, 8205, 129309, 8205, 128105, 127998], + &[128105, 127999, 8205, 129775, 8205, 128105, 127995], + &[128105, 127999, 8205, 129775, 8205, 128105, 127996], + &[128105, 127999, 8205, 129775, 8205, 128105, 127997], + &[128105, 127999, 8205, 129775, 8205, 128105, 127998], + &[129489, 8205, 129309, 8205, 129489], + &[129489, 8205, 129489, 8205, 129490], + &[129489, 8205, 129489, 8205, 129490, 8205, 129490], + &[129489, 8205, 129490], + &[129489, 8205, 129490, 8205, 129490], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[ + 129489, 127995, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127995, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127995, 8205, 129309, 8205, 129489, 127995], + &[129489, 127995, 8205, 129309, 8205, 129489, 127996], + &[129489, 127995, 8205, 129309, 8205, 129489, 127997], + &[129489, 127995, 8205, 129309, 8205, 129489, 127998], + &[129489, 127995, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[ + 129489, 127996, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127996, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127996, 8205, 129309, 8205, 129489, 127995], + &[129489, 127996, 8205, 129309, 8205, 129489, 127996], + &[129489, 127996, 8205, 129309, 8205, 129489, 127997], + &[129489, 127996, 8205, 129309, 8205, 129489, 127998], + &[129489, 127996, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[ + 129489, 127997, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127997, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127997, 8205, 129309, 8205, 129489, 127995], + &[129489, 127997, 8205, 129309, 8205, 129489, 127996], + &[129489, 127997, 8205, 129309, 8205, 129489, 127997], + &[129489, 127997, 8205, 129309, 8205, 129489, 127998], + &[129489, 127997, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127998, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127999, + ], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127998, 8205, 10084, 65039, 8205, 129489, 127999], + &[129489, 127998, 8205, 129309, 8205, 129489, 127995], + &[129489, 127998, 8205, 129309, 8205, 129489, 127996], + &[129489, 127998, 8205, 129309, 8205, 129489, 127997], + &[129489, 127998, 8205, 129309, 8205, 129489, 127998], + &[129489, 127998, 8205, 129309, 8205, 129489, 127999], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127995, + ], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127996, + ], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127997, + ], + &[ + 129489, 127999, 8205, 10084, 65039, 8205, 128139, 8205, 129489, 127998, + ], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127995], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127996], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127997], + &[129489, 127999, 8205, 10084, 65039, 8205, 129489, 127998], + &[129489, 127999, 8205, 129309, 8205, 129489, 127995], + &[129489, 127999, 8205, 129309, 8205, 129489, 127996], + &[129489, 127999, 8205, 129309, 8205, 129489, 127997], + &[129489, 127999, 8205, 129309, 8205, 129489, 127998], + &[129489, 127999, 8205, 129309, 8205, 129489, 127999], + &[129777, 127995, 8205, 129778, 127996], + &[129777, 127995, 8205, 129778, 127997], + &[129777, 127995, 8205, 129778, 127998], + &[129777, 127995, 8205, 129778, 127999], + &[129777, 127996, 8205, 129778, 127995], + &[129777, 127996, 8205, 129778, 127997], + &[129777, 127996, 8205, 129778, 127998], + &[129777, 127996, 8205, 129778, 127999], + &[129777, 127997, 8205, 129778, 127995], + &[129777, 127997, 8205, 129778, 127996], + &[129777, 127997, 8205, 129778, 127998], + &[129777, 127997, 8205, 129778, 127999], + &[129777, 127998, 8205, 129778, 127995], + &[129777, 127998, 8205, 129778, 127996], + &[129777, 127998, 8205, 129778, 127997], + &[129777, 127998, 8205, 129778, 127999], + &[129777, 127999, 8205, 129778, 127995], + &[129777, 127999, 8205, 129778, 127996], + &[129777, 127999, 8205, 129778, 127997], + &[129777, 127999, 8205, 129778, 127998], + &[127939, 8205, 10145, 65039], + &[127939, 127995, 8205, 10145, 65039], + &[127939, 127996, 8205, 10145, 65039], + &[127939, 127997, 8205, 10145, 65039], + &[127939, 127998, 8205, 10145, 65039], + &[127939, 127999, 8205, 10145, 65039], + &[128104, 8205, 9877, 65039], + &[128104, 8205, 9878, 65039], + &[128104, 8205, 9992, 65039], + &[128104, 8205, 127806], + &[128104, 8205, 127859], + &[128104, 8205, 127868], + &[128104, 8205, 127891], + &[128104, 8205, 127908], + &[128104, 8205, 127912], + &[128104, 8205, 127979], + &[128104, 8205, 127981], + &[128104, 8205, 128187], + &[128104, 8205, 128188], + &[128104, 8205, 128295], + &[128104, 8205, 128300], + &[128104, 8205, 128640], + &[128104, 8205, 128658], + &[128104, 8205, 129455], + &[128104, 8205, 129455, 8205, 10145, 65039], + &[128104, 8205, 129468], + &[128104, 8205, 129468, 8205, 10145, 65039], + &[128104, 8205, 129469], + &[128104, 8205, 129469, 8205, 10145, 65039], + &[128104, 127995, 8205, 9877, 65039], + &[128104, 127995, 8205, 9878, 65039], + &[128104, 127995, 8205, 9992, 65039], + &[128104, 127995, 8205, 127806], + &[128104, 127995, 8205, 127859], + &[128104, 127995, 8205, 127868], + &[128104, 127995, 8205, 127891], + &[128104, 127995, 8205, 127908], + &[128104, 127995, 8205, 127912], + &[128104, 127995, 8205, 127979], + &[128104, 127995, 8205, 127981], + &[128104, 127995, 8205, 128187], + &[128104, 127995, 8205, 128188], + &[128104, 127995, 8205, 128295], + &[128104, 127995, 8205, 128300], + &[128104, 127995, 8205, 128640], + &[128104, 127995, 8205, 128658], + &[128104, 127995, 8205, 129455], + &[128104, 127995, 8205, 129455, 8205, 10145, 65039], + &[128104, 127995, 8205, 129468], + &[128104, 127995, 8205, 129468, 8205, 10145, 65039], + &[128104, 127995, 8205, 129469], + &[128104, 127995, 8205, 129469, 8205, 10145, 65039], + &[128104, 127996, 8205, 9877, 65039], + &[128104, 127996, 8205, 9878, 65039], + &[128104, 127996, 8205, 9992, 65039], + &[128104, 127996, 8205, 127806], + &[128104, 127996, 8205, 127859], + &[128104, 127996, 8205, 127868], + &[128104, 127996, 8205, 127891], + &[128104, 127996, 8205, 127908], + &[128104, 127996, 8205, 127912], + &[128104, 127996, 8205, 127979], + &[128104, 127996, 8205, 127981], + &[128104, 127996, 8205, 128187], + &[128104, 127996, 8205, 128188], + &[128104, 127996, 8205, 128295], + &[128104, 127996, 8205, 128300], + &[128104, 127996, 8205, 128640], + &[128104, 127996, 8205, 128658], + &[128104, 127996, 8205, 129455], + &[128104, 127996, 8205, 129455, 8205, 10145, 65039], + &[128104, 127996, 8205, 129468], + &[128104, 127996, 8205, 129468, 8205, 10145, 65039], + &[128104, 127996, 8205, 129469], + &[128104, 127996, 8205, 129469, 8205, 10145, 65039], + &[128104, 127997, 8205, 9877, 65039], + &[128104, 127997, 8205, 9878, 65039], + &[128104, 127997, 8205, 9992, 65039], + &[128104, 127997, 8205, 127806], + &[128104, 127997, 8205, 127859], + &[128104, 127997, 8205, 127868], + &[128104, 127997, 8205, 127891], + &[128104, 127997, 8205, 127908], + &[128104, 127997, 8205, 127912], + &[128104, 127997, 8205, 127979], + &[128104, 127997, 8205, 127981], + &[128104, 127997, 8205, 128187], + &[128104, 127997, 8205, 128188], + &[128104, 127997, 8205, 128295], + &[128104, 127997, 8205, 128300], + &[128104, 127997, 8205, 128640], + &[128104, 127997, 8205, 128658], + &[128104, 127997, 8205, 129455], + &[128104, 127997, 8205, 129455, 8205, 10145, 65039], + &[128104, 127997, 8205, 129468], + &[128104, 127997, 8205, 129468, 8205, 10145, 65039], + &[128104, 127997, 8205, 129469], + &[128104, 127997, 8205, 129469, 8205, 10145, 65039], + &[128104, 127998, 8205, 9877, 65039], + &[128104, 127998, 8205, 9878, 65039], + &[128104, 127998, 8205, 9992, 65039], + &[128104, 127998, 8205, 127806], + &[128104, 127998, 8205, 127859], + &[128104, 127998, 8205, 127868], + &[128104, 127998, 8205, 127891], + &[128104, 127998, 8205, 127908], + &[128104, 127998, 8205, 127912], + &[128104, 127998, 8205, 127979], + &[128104, 127998, 8205, 127981], + &[128104, 127998, 8205, 128187], + &[128104, 127998, 8205, 128188], + &[128104, 127998, 8205, 128295], + &[128104, 127998, 8205, 128300], + &[128104, 127998, 8205, 128640], + &[128104, 127998, 8205, 128658], + &[128104, 127998, 8205, 129455], + &[128104, 127998, 8205, 129455, 8205, 10145, 65039], + &[128104, 127998, 8205, 129468], + &[128104, 127998, 8205, 129468, 8205, 10145, 65039], + &[128104, 127998, 8205, 129469], + &[128104, 127998, 8205, 129469, 8205, 10145, 65039], + &[128104, 127999, 8205, 9877, 65039], + &[128104, 127999, 8205, 9878, 65039], + &[128104, 127999, 8205, 9992, 65039], + &[128104, 127999, 8205, 127806], + &[128104, 127999, 8205, 127859], + &[128104, 127999, 8205, 127868], + &[128104, 127999, 8205, 127891], + &[128104, 127999, 8205, 127908], + &[128104, 127999, 8205, 127912], + &[128104, 127999, 8205, 127979], + &[128104, 127999, 8205, 127981], + &[128104, 127999, 8205, 128187], + &[128104, 127999, 8205, 128188], + &[128104, 127999, 8205, 128295], + &[128104, 127999, 8205, 128300], + &[128104, 127999, 8205, 128640], + &[128104, 127999, 8205, 128658], + &[128104, 127999, 8205, 129455], + &[128104, 127999, 8205, 129455, 8205, 10145, 65039], + &[128104, 127999, 8205, 129468], + &[128104, 127999, 8205, 129468, 8205, 10145, 65039], + &[128104, 127999, 8205, 129469], + &[128104, 127999, 8205, 129469, 8205, 10145, 65039], + &[128105, 8205, 9877, 65039], + &[128105, 8205, 9878, 65039], + &[128105, 8205, 9992, 65039], + &[128105, 8205, 127806], + &[128105, 8205, 127859], + &[128105, 8205, 127868], + &[128105, 8205, 127891], + &[128105, 8205, 127908], + &[128105, 8205, 127912], + &[128105, 8205, 127979], + &[128105, 8205, 127981], + &[128105, 8205, 128187], + &[128105, 8205, 128188], + &[128105, 8205, 128295], + &[128105, 8205, 128300], + &[128105, 8205, 128640], + &[128105, 8205, 128658], + &[128105, 8205, 129455], + &[128105, 8205, 129455, 8205, 10145, 65039], + &[128105, 8205, 129468], + &[128105, 8205, 129468, 8205, 10145, 65039], + &[128105, 8205, 129469], + &[128105, 8205, 129469, 8205, 10145, 65039], + &[128105, 127995, 8205, 9877, 65039], + &[128105, 127995, 8205, 9878, 65039], + &[128105, 127995, 8205, 9992, 65039], + &[128105, 127995, 8205, 127806], + &[128105, 127995, 8205, 127859], + &[128105, 127995, 8205, 127868], + &[128105, 127995, 8205, 127891], + &[128105, 127995, 8205, 127908], + &[128105, 127995, 8205, 127912], + &[128105, 127995, 8205, 127979], + &[128105, 127995, 8205, 127981], + &[128105, 127995, 8205, 128187], + &[128105, 127995, 8205, 128188], + &[128105, 127995, 8205, 128295], + &[128105, 127995, 8205, 128300], + &[128105, 127995, 8205, 128640], + &[128105, 127995, 8205, 128658], + &[128105, 127995, 8205, 129455], + &[128105, 127995, 8205, 129455, 8205, 10145, 65039], + &[128105, 127995, 8205, 129468], + &[128105, 127995, 8205, 129468, 8205, 10145, 65039], + &[128105, 127995, 8205, 129469], + &[128105, 127995, 8205, 129469, 8205, 10145, 65039], + &[128105, 127996, 8205, 9877, 65039], + &[128105, 127996, 8205, 9878, 65039], + &[128105, 127996, 8205, 9992, 65039], + &[128105, 127996, 8205, 127806], + &[128105, 127996, 8205, 127859], + &[128105, 127996, 8205, 127868], + &[128105, 127996, 8205, 127891], + &[128105, 127996, 8205, 127908], + &[128105, 127996, 8205, 127912], + &[128105, 127996, 8205, 127979], + &[128105, 127996, 8205, 127981], + &[128105, 127996, 8205, 128187], + &[128105, 127996, 8205, 128188], + &[128105, 127996, 8205, 128295], + &[128105, 127996, 8205, 128300], + &[128105, 127996, 8205, 128640], + &[128105, 127996, 8205, 128658], + &[128105, 127996, 8205, 129455], + &[128105, 127996, 8205, 129455, 8205, 10145, 65039], + &[128105, 127996, 8205, 129468], + &[128105, 127996, 8205, 129468, 8205, 10145, 65039], + &[128105, 127996, 8205, 129469], + &[128105, 127996, 8205, 129469, 8205, 10145, 65039], + &[128105, 127997, 8205, 9877, 65039], + &[128105, 127997, 8205, 9878, 65039], + &[128105, 127997, 8205, 9992, 65039], + &[128105, 127997, 8205, 127806], + &[128105, 127997, 8205, 127859], + &[128105, 127997, 8205, 127868], + &[128105, 127997, 8205, 127891], + &[128105, 127997, 8205, 127908], + &[128105, 127997, 8205, 127912], + &[128105, 127997, 8205, 127979], + &[128105, 127997, 8205, 127981], + &[128105, 127997, 8205, 128187], + &[128105, 127997, 8205, 128188], + &[128105, 127997, 8205, 128295], + &[128105, 127997, 8205, 128300], + &[128105, 127997, 8205, 128640], + &[128105, 127997, 8205, 128658], + &[128105, 127997, 8205, 129455], + &[128105, 127997, 8205, 129455, 8205, 10145, 65039], + &[128105, 127997, 8205, 129468], + &[128105, 127997, 8205, 129468, 8205, 10145, 65039], + &[128105, 127997, 8205, 129469], + &[128105, 127997, 8205, 129469, 8205, 10145, 65039], + &[128105, 127998, 8205, 9877, 65039], + &[128105, 127998, 8205, 9878, 65039], + &[128105, 127998, 8205, 9992, 65039], + &[128105, 127998, 8205, 127806], + &[128105, 127998, 8205, 127859], + &[128105, 127998, 8205, 127868], + &[128105, 127998, 8205, 127891], + &[128105, 127998, 8205, 127908], + &[128105, 127998, 8205, 127912], + &[128105, 127998, 8205, 127979], + &[128105, 127998, 8205, 127981], + &[128105, 127998, 8205, 128187], + &[128105, 127998, 8205, 128188], + &[128105, 127998, 8205, 128295], + &[128105, 127998, 8205, 128300], + &[128105, 127998, 8205, 128640], + &[128105, 127998, 8205, 128658], + &[128105, 127998, 8205, 129455], + &[128105, 127998, 8205, 129455, 8205, 10145, 65039], + &[128105, 127998, 8205, 129468], + &[128105, 127998, 8205, 129468, 8205, 10145, 65039], + &[128105, 127998, 8205, 129469], + &[128105, 127998, 8205, 129469, 8205, 10145, 65039], + &[128105, 127999, 8205, 9877, 65039], + &[128105, 127999, 8205, 9878, 65039], + &[128105, 127999, 8205, 9992, 65039], + &[128105, 127999, 8205, 127806], + &[128105, 127999, 8205, 127859], + &[128105, 127999, 8205, 127868], + &[128105, 127999, 8205, 127891], + &[128105, 127999, 8205, 127908], + &[128105, 127999, 8205, 127912], + &[128105, 127999, 8205, 127979], + &[128105, 127999, 8205, 127981], + &[128105, 127999, 8205, 128187], + &[128105, 127999, 8205, 128188], + &[128105, 127999, 8205, 128295], + &[128105, 127999, 8205, 128300], + &[128105, 127999, 8205, 128640], + &[128105, 127999, 8205, 128658], + &[128105, 127999, 8205, 129455], + &[128105, 127999, 8205, 129455, 8205, 10145, 65039], + &[128105, 127999, 8205, 129468], + &[128105, 127999, 8205, 129468, 8205, 10145, 65039], + &[128105, 127999, 8205, 129469], + &[128105, 127999, 8205, 129469, 8205, 10145, 65039], + &[128694, 8205, 10145, 65039], + &[128694, 127995, 8205, 10145, 65039], + &[128694, 127996, 8205, 10145, 65039], + &[128694, 127997, 8205, 10145, 65039], + &[128694, 127998, 8205, 10145, 65039], + &[128694, 127999, 8205, 10145, 65039], + &[129486, 8205, 10145, 65039], + &[129486, 127995, 8205, 10145, 65039], + &[129486, 127996, 8205, 10145, 65039], + &[129486, 127997, 8205, 10145, 65039], + &[129486, 127998, 8205, 10145, 65039], + &[129486, 127999, 8205, 10145, 65039], + &[129489, 8205, 9877, 65039], + &[129489, 8205, 9878, 65039], + &[129489, 8205, 9992, 65039], + &[129489, 8205, 127806], + &[129489, 8205, 127859], + &[129489, 8205, 127868], + &[129489, 8205, 127876], + &[129489, 8205, 127891], + &[129489, 8205, 127908], + &[129489, 8205, 127912], + &[129489, 8205, 127979], + &[129489, 8205, 127981], + &[129489, 8205, 128187], + &[129489, 8205, 128188], + &[129489, 8205, 128295], + &[129489, 8205, 128300], + &[129489, 8205, 128640], + &[129489, 8205, 128658], + &[129489, 8205, 129455], + &[129489, 8205, 129455, 8205, 10145, 65039], + &[129489, 8205, 129468], + &[129489, 8205, 129468, 8205, 10145, 65039], + &[129489, 8205, 129469], + &[129489, 8205, 129469, 8205, 10145, 65039], + &[129489, 127995, 8205, 9877, 65039], + &[129489, 127995, 8205, 9878, 65039], + &[129489, 127995, 8205, 9992, 65039], + &[129489, 127995, 8205, 127806], + &[129489, 127995, 8205, 127859], + &[129489, 127995, 8205, 127868], + &[129489, 127995, 8205, 127876], + &[129489, 127995, 8205, 127891], + &[129489, 127995, 8205, 127908], + &[129489, 127995, 8205, 127912], + &[129489, 127995, 8205, 127979], + &[129489, 127995, 8205, 127981], + &[129489, 127995, 8205, 128187], + &[129489, 127995, 8205, 128188], + &[129489, 127995, 8205, 128295], + &[129489, 127995, 8205, 128300], + &[129489, 127995, 8205, 128640], + &[129489, 127995, 8205, 128658], + &[129489, 127995, 8205, 129455], + &[129489, 127995, 8205, 129455, 8205, 10145, 65039], + &[129489, 127995, 8205, 129468], + &[129489, 127995, 8205, 129468, 8205, 10145, 65039], + &[129489, 127995, 8205, 129469], + &[129489, 127995, 8205, 129469, 8205, 10145, 65039], + &[129489, 127996, 8205, 9877, 65039], + &[129489, 127996, 8205, 9878, 65039], + &[129489, 127996, 8205, 9992, 65039], + &[129489, 127996, 8205, 127806], + &[129489, 127996, 8205, 127859], + &[129489, 127996, 8205, 127868], + &[129489, 127996, 8205, 127876], + &[129489, 127996, 8205, 127891], + &[129489, 127996, 8205, 127908], + &[129489, 127996, 8205, 127912], + &[129489, 127996, 8205, 127979], + &[129489, 127996, 8205, 127981], + &[129489, 127996, 8205, 128187], + &[129489, 127996, 8205, 128188], + &[129489, 127996, 8205, 128295], + &[129489, 127996, 8205, 128300], + &[129489, 127996, 8205, 128640], + &[129489, 127996, 8205, 128658], + &[129489, 127996, 8205, 129455], + &[129489, 127996, 8205, 129455, 8205, 10145, 65039], + &[129489, 127996, 8205, 129468], + &[129489, 127996, 8205, 129468, 8205, 10145, 65039], + &[129489, 127996, 8205, 129469], + &[129489, 127996, 8205, 129469, 8205, 10145, 65039], + &[129489, 127997, 8205, 9877, 65039], + &[129489, 127997, 8205, 9878, 65039], + &[129489, 127997, 8205, 9992, 65039], + &[129489, 127997, 8205, 127806], + &[129489, 127997, 8205, 127859], + &[129489, 127997, 8205, 127868], + &[129489, 127997, 8205, 127876], + &[129489, 127997, 8205, 127891], + &[129489, 127997, 8205, 127908], + &[129489, 127997, 8205, 127912], + &[129489, 127997, 8205, 127979], + &[129489, 127997, 8205, 127981], + &[129489, 127997, 8205, 128187], + &[129489, 127997, 8205, 128188], + &[129489, 127997, 8205, 128295], + &[129489, 127997, 8205, 128300], + &[129489, 127997, 8205, 128640], + &[129489, 127997, 8205, 128658], + &[129489, 127997, 8205, 129455], + &[129489, 127997, 8205, 129455, 8205, 10145, 65039], + &[129489, 127997, 8205, 129468], + &[129489, 127997, 8205, 129468, 8205, 10145, 65039], + &[129489, 127997, 8205, 129469], + &[129489, 127997, 8205, 129469, 8205, 10145, 65039], + &[129489, 127998, 8205, 9877, 65039], + &[129489, 127998, 8205, 9878, 65039], + &[129489, 127998, 8205, 9992, 65039], + &[129489, 127998, 8205, 127806], + &[129489, 127998, 8205, 127859], + &[129489, 127998, 8205, 127868], + &[129489, 127998, 8205, 127876], + &[129489, 127998, 8205, 127891], + &[129489, 127998, 8205, 127908], + &[129489, 127998, 8205, 127912], + &[129489, 127998, 8205, 127979], + &[129489, 127998, 8205, 127981], + &[129489, 127998, 8205, 128187], + &[129489, 127998, 8205, 128188], + &[129489, 127998, 8205, 128295], + &[129489, 127998, 8205, 128300], + &[129489, 127998, 8205, 128640], + &[129489, 127998, 8205, 128658], + &[129489, 127998, 8205, 129455], + &[129489, 127998, 8205, 129455, 8205, 10145, 65039], + &[129489, 127998, 8205, 129468], + &[129489, 127998, 8205, 129468, 8205, 10145, 65039], + &[129489, 127998, 8205, 129469], + &[129489, 127998, 8205, 129469, 8205, 10145, 65039], + &[129489, 127999, 8205, 9877, 65039], + &[129489, 127999, 8205, 9878, 65039], + &[129489, 127999, 8205, 9992, 65039], + &[129489, 127999, 8205, 127806], + &[129489, 127999, 8205, 127859], + &[129489, 127999, 8205, 127868], + &[129489, 127999, 8205, 127876], + &[129489, 127999, 8205, 127891], + &[129489, 127999, 8205, 127908], + &[129489, 127999, 8205, 127912], + &[129489, 127999, 8205, 127979], + &[129489, 127999, 8205, 127981], + &[129489, 127999, 8205, 128187], + &[129489, 127999, 8205, 128188], + &[129489, 127999, 8205, 128295], + &[129489, 127999, 8205, 128300], + &[129489, 127999, 8205, 128640], + &[129489, 127999, 8205, 128658], + &[129489, 127999, 8205, 129455], + &[129489, 127999, 8205, 129455, 8205, 10145, 65039], + &[129489, 127999, 8205, 129468], + &[129489, 127999, 8205, 129468, 8205, 10145, 65039], + &[129489, 127999, 8205, 129469], + &[129489, 127999, 8205, 129469, 8205, 10145, 65039], + &[9977, 127995, 8205, 9792, 65039], + &[9977, 127995, 8205, 9794, 65039], + &[9977, 127996, 8205, 9792, 65039], + &[9977, 127996, 8205, 9794, 65039], + &[9977, 127997, 8205, 9792, 65039], + &[9977, 127997, 8205, 9794, 65039], + &[9977, 127998, 8205, 9792, 65039], + &[9977, 127998, 8205, 9794, 65039], + &[9977, 127999, 8205, 9792, 65039], + &[9977, 127999, 8205, 9794, 65039], + &[9977, 65039, 8205, 9792, 65039], + &[9977, 65039, 8205, 9794, 65039], + &[127939, 8205, 9792, 65039], + &[127939, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 8205, 9794, 65039], + &[127939, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127995, 8205, 9792, 65039], + &[127939, 127995, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127995, 8205, 9794, 65039], + &[127939, 127995, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127996, 8205, 9792, 65039], + &[127939, 127996, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127996, 8205, 9794, 65039], + &[127939, 127996, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127997, 8205, 9792, 65039], + &[127939, 127997, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127997, 8205, 9794, 65039], + &[127939, 127997, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127998, 8205, 9792, 65039], + &[127939, 127998, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127998, 8205, 9794, 65039], + &[127939, 127998, 8205, 9794, 65039, 8205, 10145, 65039], + &[127939, 127999, 8205, 9792, 65039], + &[127939, 127999, 8205, 9792, 65039, 8205, 10145, 65039], + &[127939, 127999, 8205, 9794, 65039], + &[127939, 127999, 8205, 9794, 65039, 8205, 10145, 65039], + &[127940, 8205, 9792, 65039], + &[127940, 8205, 9794, 65039], + &[127940, 127995, 8205, 9792, 65039], + &[127940, 127995, 8205, 9794, 65039], + &[127940, 127996, 8205, 9792, 65039], + &[127940, 127996, 8205, 9794, 65039], + &[127940, 127997, 8205, 9792, 65039], + &[127940, 127997, 8205, 9794, 65039], + &[127940, 127998, 8205, 9792, 65039], + &[127940, 127998, 8205, 9794, 65039], + &[127940, 127999, 8205, 9792, 65039], + &[127940, 127999, 8205, 9794, 65039], + &[127946, 8205, 9792, 65039], + &[127946, 8205, 9794, 65039], + &[127946, 127995, 8205, 9792, 65039], + &[127946, 127995, 8205, 9794, 65039], + &[127946, 127996, 8205, 9792, 65039], + &[127946, 127996, 8205, 9794, 65039], + &[127946, 127997, 8205, 9792, 65039], + &[127946, 127997, 8205, 9794, 65039], + &[127946, 127998, 8205, 9792, 65039], + &[127946, 127998, 8205, 9794, 65039], + &[127946, 127999, 8205, 9792, 65039], + &[127946, 127999, 8205, 9794, 65039], + &[127947, 127995, 8205, 9792, 65039], + &[127947, 127995, 8205, 9794, 65039], + &[127947, 127996, 8205, 9792, 65039], + &[127947, 127996, 8205, 9794, 65039], + &[127947, 127997, 8205, 9792, 65039], + &[127947, 127997, 8205, 9794, 65039], + &[127947, 127998, 8205, 9792, 65039], + &[127947, 127998, 8205, 9794, 65039], + &[127947, 127999, 8205, 9792, 65039], + &[127947, 127999, 8205, 9794, 65039], + &[127947, 65039, 8205, 9792, 65039], + &[127947, 65039, 8205, 9794, 65039], + &[127948, 127995, 8205, 9792, 65039], + &[127948, 127995, 8205, 9794, 65039], + &[127948, 127996, 8205, 9792, 65039], + &[127948, 127996, 8205, 9794, 65039], + &[127948, 127997, 8205, 9792, 65039], + &[127948, 127997, 8205, 9794, 65039], + &[127948, 127998, 8205, 9792, 65039], + &[127948, 127998, 8205, 9794, 65039], + &[127948, 127999, 8205, 9792, 65039], + &[127948, 127999, 8205, 9794, 65039], + &[127948, 65039, 8205, 9792, 65039], + &[127948, 65039, 8205, 9794, 65039], + &[128110, 8205, 9792, 65039], + &[128110, 8205, 9794, 65039], + &[128110, 127995, 8205, 9792, 65039], + &[128110, 127995, 8205, 9794, 65039], + &[128110, 127996, 8205, 9792, 65039], + &[128110, 127996, 8205, 9794, 65039], + &[128110, 127997, 8205, 9792, 65039], + &[128110, 127997, 8205, 9794, 65039], + &[128110, 127998, 8205, 9792, 65039], + &[128110, 127998, 8205, 9794, 65039], + &[128110, 127999, 8205, 9792, 65039], + &[128110, 127999, 8205, 9794, 65039], + &[128111, 8205, 9792, 65039], + &[128111, 8205, 9794, 65039], + &[128111, 127995, 8205, 9792, 65039], + &[128111, 127995, 8205, 9794, 65039], + &[128111, 127996, 8205, 9792, 65039], + &[128111, 127996, 8205, 9794, 65039], + &[128111, 127997, 8205, 9792, 65039], + &[128111, 127997, 8205, 9794, 65039], + &[128111, 127998, 8205, 9792, 65039], + &[128111, 127998, 8205, 9794, 65039], + &[128111, 127999, 8205, 9792, 65039], + &[128111, 127999, 8205, 9794, 65039], + &[128112, 8205, 9792, 65039], + &[128112, 8205, 9794, 65039], + &[128112, 127995, 8205, 9792, 65039], + &[128112, 127995, 8205, 9794, 65039], + &[128112, 127996, 8205, 9792, 65039], + &[128112, 127996, 8205, 9794, 65039], + &[128112, 127997, 8205, 9792, 65039], + &[128112, 127997, 8205, 9794, 65039], + &[128112, 127998, 8205, 9792, 65039], + &[128112, 127998, 8205, 9794, 65039], + &[128112, 127999, 8205, 9792, 65039], + &[128112, 127999, 8205, 9794, 65039], + &[128113, 8205, 9792, 65039], + &[128113, 8205, 9794, 65039], + &[128113, 127995, 8205, 9792, 65039], + &[128113, 127995, 8205, 9794, 65039], + &[128113, 127996, 8205, 9792, 65039], + &[128113, 127996, 8205, 9794, 65039], + &[128113, 127997, 8205, 9792, 65039], + &[128113, 127997, 8205, 9794, 65039], + &[128113, 127998, 8205, 9792, 65039], + &[128113, 127998, 8205, 9794, 65039], + &[128113, 127999, 8205, 9792, 65039], + &[128113, 127999, 8205, 9794, 65039], + &[128115, 8205, 9792, 65039], + &[128115, 8205, 9794, 65039], + &[128115, 127995, 8205, 9792, 65039], + &[128115, 127995, 8205, 9794, 65039], + &[128115, 127996, 8205, 9792, 65039], + &[128115, 127996, 8205, 9794, 65039], + &[128115, 127997, 8205, 9792, 65039], + &[128115, 127997, 8205, 9794, 65039], + &[128115, 127998, 8205, 9792, 65039], + &[128115, 127998, 8205, 9794, 65039], + &[128115, 127999, 8205, 9792, 65039], + &[128115, 127999, 8205, 9794, 65039], + &[128119, 8205, 9792, 65039], + &[128119, 8205, 9794, 65039], + &[128119, 127995, 8205, 9792, 65039], + &[128119, 127995, 8205, 9794, 65039], + &[128119, 127996, 8205, 9792, 65039], + &[128119, 127996, 8205, 9794, 65039], + &[128119, 127997, 8205, 9792, 65039], + &[128119, 127997, 8205, 9794, 65039], + &[128119, 127998, 8205, 9792, 65039], + &[128119, 127998, 8205, 9794, 65039], + &[128119, 127999, 8205, 9792, 65039], + &[128119, 127999, 8205, 9794, 65039], + &[128129, 8205, 9792, 65039], + &[128129, 8205, 9794, 65039], + &[128129, 127995, 8205, 9792, 65039], + &[128129, 127995, 8205, 9794, 65039], + &[128129, 127996, 8205, 9792, 65039], + &[128129, 127996, 8205, 9794, 65039], + &[128129, 127997, 8205, 9792, 65039], + &[128129, 127997, 8205, 9794, 65039], + &[128129, 127998, 8205, 9792, 65039], + &[128129, 127998, 8205, 9794, 65039], + &[128129, 127999, 8205, 9792, 65039], + &[128129, 127999, 8205, 9794, 65039], + &[128130, 8205, 9792, 65039], + &[128130, 8205, 9794, 65039], + &[128130, 127995, 8205, 9792, 65039], + &[128130, 127995, 8205, 9794, 65039], + &[128130, 127996, 8205, 9792, 65039], + &[128130, 127996, 8205, 9794, 65039], + &[128130, 127997, 8205, 9792, 65039], + &[128130, 127997, 8205, 9794, 65039], + &[128130, 127998, 8205, 9792, 65039], + &[128130, 127998, 8205, 9794, 65039], + &[128130, 127999, 8205, 9792, 65039], + &[128130, 127999, 8205, 9794, 65039], + &[128134, 8205, 9792, 65039], + &[128134, 8205, 9794, 65039], + &[128134, 127995, 8205, 9792, 65039], + &[128134, 127995, 8205, 9794, 65039], + &[128134, 127996, 8205, 9792, 65039], + &[128134, 127996, 8205, 9794, 65039], + &[128134, 127997, 8205, 9792, 65039], + &[128134, 127997, 8205, 9794, 65039], + &[128134, 127998, 8205, 9792, 65039], + &[128134, 127998, 8205, 9794, 65039], + &[128134, 127999, 8205, 9792, 65039], + &[128134, 127999, 8205, 9794, 65039], + &[128135, 8205, 9792, 65039], + &[128135, 8205, 9794, 65039], + &[128135, 127995, 8205, 9792, 65039], + &[128135, 127995, 8205, 9794, 65039], + &[128135, 127996, 8205, 9792, 65039], + &[128135, 127996, 8205, 9794, 65039], + &[128135, 127997, 8205, 9792, 65039], + &[128135, 127997, 8205, 9794, 65039], + &[128135, 127998, 8205, 9792, 65039], + &[128135, 127998, 8205, 9794, 65039], + &[128135, 127999, 8205, 9792, 65039], + &[128135, 127999, 8205, 9794, 65039], + &[128373, 127995, 8205, 9792, 65039], + &[128373, 127995, 8205, 9794, 65039], + &[128373, 127996, 8205, 9792, 65039], + &[128373, 127996, 8205, 9794, 65039], + &[128373, 127997, 8205, 9792, 65039], + &[128373, 127997, 8205, 9794, 65039], + &[128373, 127998, 8205, 9792, 65039], + &[128373, 127998, 8205, 9794, 65039], + &[128373, 127999, 8205, 9792, 65039], + &[128373, 127999, 8205, 9794, 65039], + &[128373, 65039, 8205, 9792, 65039], + &[128373, 65039, 8205, 9794, 65039], + &[128581, 8205, 9792, 65039], + &[128581, 8205, 9794, 65039], + &[128581, 127995, 8205, 9792, 65039], + &[128581, 127995, 8205, 9794, 65039], + &[128581, 127996, 8205, 9792, 65039], + &[128581, 127996, 8205, 9794, 65039], + &[128581, 127997, 8205, 9792, 65039], + &[128581, 127997, 8205, 9794, 65039], + &[128581, 127998, 8205, 9792, 65039], + &[128581, 127998, 8205, 9794, 65039], + &[128581, 127999, 8205, 9792, 65039], + &[128581, 127999, 8205, 9794, 65039], + &[128582, 8205, 9792, 65039], + &[128582, 8205, 9794, 65039], + &[128582, 127995, 8205, 9792, 65039], + &[128582, 127995, 8205, 9794, 65039], + &[128582, 127996, 8205, 9792, 65039], + &[128582, 127996, 8205, 9794, 65039], + &[128582, 127997, 8205, 9792, 65039], + &[128582, 127997, 8205, 9794, 65039], + &[128582, 127998, 8205, 9792, 65039], + &[128582, 127998, 8205, 9794, 65039], + &[128582, 127999, 8205, 9792, 65039], + &[128582, 127999, 8205, 9794, 65039], + &[128583, 8205, 9792, 65039], + &[128583, 8205, 9794, 65039], + &[128583, 127995, 8205, 9792, 65039], + &[128583, 127995, 8205, 9794, 65039], + &[128583, 127996, 8205, 9792, 65039], + &[128583, 127996, 8205, 9794, 65039], + &[128583, 127997, 8205, 9792, 65039], + &[128583, 127997, 8205, 9794, 65039], + &[128583, 127998, 8205, 9792, 65039], + &[128583, 127998, 8205, 9794, 65039], + &[128583, 127999, 8205, 9792, 65039], + &[128583, 127999, 8205, 9794, 65039], + &[128587, 8205, 9792, 65039], + &[128587, 8205, 9794, 65039], + &[128587, 127995, 8205, 9792, 65039], + &[128587, 127995, 8205, 9794, 65039], + &[128587, 127996, 8205, 9792, 65039], + &[128587, 127996, 8205, 9794, 65039], + &[128587, 127997, 8205, 9792, 65039], + &[128587, 127997, 8205, 9794, 65039], + &[128587, 127998, 8205, 9792, 65039], + &[128587, 127998, 8205, 9794, 65039], + &[128587, 127999, 8205, 9792, 65039], + &[128587, 127999, 8205, 9794, 65039], + &[128589, 8205, 9792, 65039], + &[128589, 8205, 9794, 65039], + &[128589, 127995, 8205, 9792, 65039], + &[128589, 127995, 8205, 9794, 65039], + &[128589, 127996, 8205, 9792, 65039], + &[128589, 127996, 8205, 9794, 65039], + &[128589, 127997, 8205, 9792, 65039], + &[128589, 127997, 8205, 9794, 65039], + &[128589, 127998, 8205, 9792, 65039], + &[128589, 127998, 8205, 9794, 65039], + &[128589, 127999, 8205, 9792, 65039], + &[128589, 127999, 8205, 9794, 65039], + &[128590, 8205, 9792, 65039], + &[128590, 8205, 9794, 65039], + &[128590, 127995, 8205, 9792, 65039], + &[128590, 127995, 8205, 9794, 65039], + &[128590, 127996, 8205, 9792, 65039], + &[128590, 127996, 8205, 9794, 65039], + &[128590, 127997, 8205, 9792, 65039], + &[128590, 127997, 8205, 9794, 65039], + &[128590, 127998, 8205, 9792, 65039], + &[128590, 127998, 8205, 9794, 65039], + &[128590, 127999, 8205, 9792, 65039], + &[128590, 127999, 8205, 9794, 65039], + &[128675, 8205, 9792, 65039], + &[128675, 8205, 9794, 65039], + &[128675, 127995, 8205, 9792, 65039], + &[128675, 127995, 8205, 9794, 65039], + &[128675, 127996, 8205, 9792, 65039], + &[128675, 127996, 8205, 9794, 65039], + &[128675, 127997, 8205, 9792, 65039], + &[128675, 127997, 8205, 9794, 65039], + &[128675, 127998, 8205, 9792, 65039], + &[128675, 127998, 8205, 9794, 65039], + &[128675, 127999, 8205, 9792, 65039], + &[128675, 127999, 8205, 9794, 65039], + &[128692, 8205, 9792, 65039], + &[128692, 8205, 9794, 65039], + &[128692, 127995, 8205, 9792, 65039], + &[128692, 127995, 8205, 9794, 65039], + &[128692, 127996, 8205, 9792, 65039], + &[128692, 127996, 8205, 9794, 65039], + &[128692, 127997, 8205, 9792, 65039], + &[128692, 127997, 8205, 9794, 65039], + &[128692, 127998, 8205, 9792, 65039], + &[128692, 127998, 8205, 9794, 65039], + &[128692, 127999, 8205, 9792, 65039], + &[128692, 127999, 8205, 9794, 65039], + &[128693, 8205, 9792, 65039], + &[128693, 8205, 9794, 65039], + &[128693, 127995, 8205, 9792, 65039], + &[128693, 127995, 8205, 9794, 65039], + &[128693, 127996, 8205, 9792, 65039], + &[128693, 127996, 8205, 9794, 65039], + &[128693, 127997, 8205, 9792, 65039], + &[128693, 127997, 8205, 9794, 65039], + &[128693, 127998, 8205, 9792, 65039], + &[128693, 127998, 8205, 9794, 65039], + &[128693, 127999, 8205, 9792, 65039], + &[128693, 127999, 8205, 9794, 65039], + &[128694, 8205, 9792, 65039], + &[128694, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 8205, 9794, 65039], + &[128694, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127995, 8205, 9792, 65039], + &[128694, 127995, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127995, 8205, 9794, 65039], + &[128694, 127995, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127996, 8205, 9792, 65039], + &[128694, 127996, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127996, 8205, 9794, 65039], + &[128694, 127996, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127997, 8205, 9792, 65039], + &[128694, 127997, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127997, 8205, 9794, 65039], + &[128694, 127997, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127998, 8205, 9792, 65039], + &[128694, 127998, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127998, 8205, 9794, 65039], + &[128694, 127998, 8205, 9794, 65039, 8205, 10145, 65039], + &[128694, 127999, 8205, 9792, 65039], + &[128694, 127999, 8205, 9792, 65039, 8205, 10145, 65039], + &[128694, 127999, 8205, 9794, 65039], + &[128694, 127999, 8205, 9794, 65039, 8205, 10145, 65039], + &[129318, 8205, 9792, 65039], + &[129318, 8205, 9794, 65039], + &[129318, 127995, 8205, 9792, 65039], + &[129318, 127995, 8205, 9794, 65039], + &[129318, 127996, 8205, 9792, 65039], + &[129318, 127996, 8205, 9794, 65039], + &[129318, 127997, 8205, 9792, 65039], + &[129318, 127997, 8205, 9794, 65039], + &[129318, 127998, 8205, 9792, 65039], + &[129318, 127998, 8205, 9794, 65039], + &[129318, 127999, 8205, 9792, 65039], + &[129318, 127999, 8205, 9794, 65039], + &[129333, 8205, 9792, 65039], + &[129333, 8205, 9794, 65039], + &[129333, 127995, 8205, 9792, 65039], + &[129333, 127995, 8205, 9794, 65039], + &[129333, 127996, 8205, 9792, 65039], + &[129333, 127996, 8205, 9794, 65039], + &[129333, 127997, 8205, 9792, 65039], + &[129333, 127997, 8205, 9794, 65039], + &[129333, 127998, 8205, 9792, 65039], + &[129333, 127998, 8205, 9794, 65039], + &[129333, 127999, 8205, 9792, 65039], + &[129333, 127999, 8205, 9794, 65039], + &[129335, 8205, 9792, 65039], + &[129335, 8205, 9794, 65039], + &[129335, 127995, 8205, 9792, 65039], + &[129335, 127995, 8205, 9794, 65039], + &[129335, 127996, 8205, 9792, 65039], + &[129335, 127996, 8205, 9794, 65039], + &[129335, 127997, 8205, 9792, 65039], + &[129335, 127997, 8205, 9794, 65039], + &[129335, 127998, 8205, 9792, 65039], + &[129335, 127998, 8205, 9794, 65039], + &[129335, 127999, 8205, 9792, 65039], + &[129335, 127999, 8205, 9794, 65039], + &[129336, 8205, 9792, 65039], + &[129336, 8205, 9794, 65039], + &[129336, 127995, 8205, 9792, 65039], + &[129336, 127995, 8205, 9794, 65039], + &[129336, 127996, 8205, 9792, 65039], + &[129336, 127996, 8205, 9794, 65039], + &[129336, 127997, 8205, 9792, 65039], + &[129336, 127997, 8205, 9794, 65039], + &[129336, 127998, 8205, 9792, 65039], + &[129336, 127998, 8205, 9794, 65039], + &[129336, 127999, 8205, 9792, 65039], + &[129336, 127999, 8205, 9794, 65039], + &[129337, 8205, 9792, 65039], + &[129337, 8205, 9794, 65039], + &[129337, 127995, 8205, 9792, 65039], + &[129337, 127995, 8205, 9794, 65039], + &[129337, 127996, 8205, 9792, 65039], + &[129337, 127996, 8205, 9794, 65039], + &[129337, 127997, 8205, 9792, 65039], + &[129337, 127997, 8205, 9794, 65039], + &[129337, 127998, 8205, 9792, 65039], + &[129337, 127998, 8205, 9794, 65039], + &[129337, 127999, 8205, 9792, 65039], + &[129337, 127999, 8205, 9794, 65039], + &[129340, 8205, 9792, 65039], + &[129340, 8205, 9794, 65039], + &[129340, 127995, 8205, 9792, 65039], + &[129340, 127995, 8205, 9794, 65039], + &[129340, 127996, 8205, 9792, 65039], + &[129340, 127996, 8205, 9794, 65039], + &[129340, 127997, 8205, 9792, 65039], + &[129340, 127997, 8205, 9794, 65039], + &[129340, 127998, 8205, 9792, 65039], + &[129340, 127998, 8205, 9794, 65039], + &[129340, 127999, 8205, 9792, 65039], + &[129340, 127999, 8205, 9794, 65039], + &[129341, 8205, 9792, 65039], + &[129341, 8205, 9794, 65039], + &[129341, 127995, 8205, 9792, 65039], + &[129341, 127995, 8205, 9794, 65039], + &[129341, 127996, 8205, 9792, 65039], + &[129341, 127996, 8205, 9794, 65039], + &[129341, 127997, 8205, 9792, 65039], + &[129341, 127997, 8205, 9794, 65039], + &[129341, 127998, 8205, 9792, 65039], + &[129341, 127998, 8205, 9794, 65039], + &[129341, 127999, 8205, 9792, 65039], + &[129341, 127999, 8205, 9794, 65039], + &[129342, 8205, 9792, 65039], + &[129342, 8205, 9794, 65039], + &[129342, 127995, 8205, 9792, 65039], + &[129342, 127995, 8205, 9794, 65039], + &[129342, 127996, 8205, 9792, 65039], + &[129342, 127996, 8205, 9794, 65039], + &[129342, 127997, 8205, 9792, 65039], + &[129342, 127997, 8205, 9794, 65039], + &[129342, 127998, 8205, 9792, 65039], + &[129342, 127998, 8205, 9794, 65039], + &[129342, 127999, 8205, 9792, 65039], + &[129342, 127999, 8205, 9794, 65039], + &[129464, 8205, 9792, 65039], + &[129464, 8205, 9794, 65039], + &[129464, 127995, 8205, 9792, 65039], + &[129464, 127995, 8205, 9794, 65039], + &[129464, 127996, 8205, 9792, 65039], + &[129464, 127996, 8205, 9794, 65039], + &[129464, 127997, 8205, 9792, 65039], + &[129464, 127997, 8205, 9794, 65039], + &[129464, 127998, 8205, 9792, 65039], + &[129464, 127998, 8205, 9794, 65039], + &[129464, 127999, 8205, 9792, 65039], + &[129464, 127999, 8205, 9794, 65039], + &[129465, 8205, 9792, 65039], + &[129465, 8205, 9794, 65039], + &[129465, 127995, 8205, 9792, 65039], + &[129465, 127995, 8205, 9794, 65039], + &[129465, 127996, 8205, 9792, 65039], + &[129465, 127996, 8205, 9794, 65039], + &[129465, 127997, 8205, 9792, 65039], + &[129465, 127997, 8205, 9794, 65039], + &[129465, 127998, 8205, 9792, 65039], + &[129465, 127998, 8205, 9794, 65039], + &[129465, 127999, 8205, 9792, 65039], + &[129465, 127999, 8205, 9794, 65039], + &[129485, 8205, 9792, 65039], + &[129485, 8205, 9794, 65039], + &[129485, 127995, 8205, 9792, 65039], + &[129485, 127995, 8205, 9794, 65039], + &[129485, 127996, 8205, 9792, 65039], + &[129485, 127996, 8205, 9794, 65039], + &[129485, 127997, 8205, 9792, 65039], + &[129485, 127997, 8205, 9794, 65039], + &[129485, 127998, 8205, 9792, 65039], + &[129485, 127998, 8205, 9794, 65039], + &[129485, 127999, 8205, 9792, 65039], + &[129485, 127999, 8205, 9794, 65039], + &[129486, 8205, 9792, 65039], + &[129486, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 8205, 9794, 65039], + &[129486, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127995, 8205, 9792, 65039], + &[129486, 127995, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127995, 8205, 9794, 65039], + &[129486, 127995, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127996, 8205, 9792, 65039], + &[129486, 127996, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127996, 8205, 9794, 65039], + &[129486, 127996, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127997, 8205, 9792, 65039], + &[129486, 127997, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127997, 8205, 9794, 65039], + &[129486, 127997, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127998, 8205, 9792, 65039], + &[129486, 127998, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127998, 8205, 9794, 65039], + &[129486, 127998, 8205, 9794, 65039, 8205, 10145, 65039], + &[129486, 127999, 8205, 9792, 65039], + &[129486, 127999, 8205, 9792, 65039, 8205, 10145, 65039], + &[129486, 127999, 8205, 9794, 65039], + &[129486, 127999, 8205, 9794, 65039, 8205, 10145, 65039], + &[129487, 8205, 9792, 65039], + &[129487, 8205, 9794, 65039], + &[129487, 127995, 8205, 9792, 65039], + &[129487, 127995, 8205, 9794, 65039], + &[129487, 127996, 8205, 9792, 65039], + &[129487, 127996, 8205, 9794, 65039], + &[129487, 127997, 8205, 9792, 65039], + &[129487, 127997, 8205, 9794, 65039], + &[129487, 127998, 8205, 9792, 65039], + &[129487, 127998, 8205, 9794, 65039], + &[129487, 127999, 8205, 9792, 65039], + &[129487, 127999, 8205, 9794, 65039], + &[129492, 8205, 9792, 65039], + &[129492, 8205, 9794, 65039], + &[129492, 127995, 8205, 9792, 65039], + &[129492, 127995, 8205, 9794, 65039], + &[129492, 127996, 8205, 9792, 65039], + &[129492, 127996, 8205, 9794, 65039], + &[129492, 127997, 8205, 9792, 65039], + &[129492, 127997, 8205, 9794, 65039], + &[129492, 127998, 8205, 9792, 65039], + &[129492, 127998, 8205, 9794, 65039], + &[129492, 127999, 8205, 9792, 65039], + &[129492, 127999, 8205, 9794, 65039], + &[129494, 8205, 9792, 65039], + &[129494, 8205, 9794, 65039], + &[129494, 127995, 8205, 9792, 65039], + &[129494, 127995, 8205, 9794, 65039], + &[129494, 127996, 8205, 9792, 65039], + &[129494, 127996, 8205, 9794, 65039], + &[129494, 127997, 8205, 9792, 65039], + &[129494, 127997, 8205, 9794, 65039], + &[129494, 127998, 8205, 9792, 65039], + &[129494, 127998, 8205, 9794, 65039], + &[129494, 127999, 8205, 9792, 65039], + &[129494, 127999, 8205, 9794, 65039], + &[129495, 8205, 9792, 65039], + &[129495, 8205, 9794, 65039], + &[129495, 127995, 8205, 9792, 65039], + &[129495, 127995, 8205, 9794, 65039], + &[129495, 127996, 8205, 9792, 65039], + &[129495, 127996, 8205, 9794, 65039], + &[129495, 127997, 8205, 9792, 65039], + &[129495, 127997, 8205, 9794, 65039], + &[129495, 127998, 8205, 9792, 65039], + &[129495, 127998, 8205, 9794, 65039], + &[129495, 127999, 8205, 9792, 65039], + &[129495, 127999, 8205, 9794, 65039], + &[129496, 8205, 9792, 65039], + &[129496, 8205, 9794, 65039], + &[129496, 127995, 8205, 9792, 65039], + &[129496, 127995, 8205, 9794, 65039], + &[129496, 127996, 8205, 9792, 65039], + &[129496, 127996, 8205, 9794, 65039], + &[129496, 127997, 8205, 9792, 65039], + &[129496, 127997, 8205, 9794, 65039], + &[129496, 127998, 8205, 9792, 65039], + &[129496, 127998, 8205, 9794, 65039], + &[129496, 127999, 8205, 9792, 65039], + &[129496, 127999, 8205, 9794, 65039], + &[129497, 8205, 9792, 65039], + &[129497, 8205, 9794, 65039], + &[129497, 127995, 8205, 9792, 65039], + &[129497, 127995, 8205, 9794, 65039], + &[129497, 127996, 8205, 9792, 65039], + &[129497, 127996, 8205, 9794, 65039], + &[129497, 127997, 8205, 9792, 65039], + &[129497, 127997, 8205, 9794, 65039], + &[129497, 127998, 8205, 9792, 65039], + &[129497, 127998, 8205, 9794, 65039], + &[129497, 127999, 8205, 9792, 65039], + &[129497, 127999, 8205, 9794, 65039], + &[129498, 8205, 9792, 65039], + &[129498, 8205, 9794, 65039], + &[129498, 127995, 8205, 9792, 65039], + &[129498, 127995, 8205, 9794, 65039], + &[129498, 127996, 8205, 9792, 65039], + &[129498, 127996, 8205, 9794, 65039], + &[129498, 127997, 8205, 9792, 65039], + &[129498, 127997, 8205, 9794, 65039], + &[129498, 127998, 8205, 9792, 65039], + &[129498, 127998, 8205, 9794, 65039], + &[129498, 127999, 8205, 9792, 65039], + &[129498, 127999, 8205, 9794, 65039], + &[129499, 8205, 9792, 65039], + &[129499, 8205, 9794, 65039], + &[129499, 127995, 8205, 9792, 65039], + &[129499, 127995, 8205, 9794, 65039], + &[129499, 127996, 8205, 9792, 65039], + &[129499, 127996, 8205, 9794, 65039], + &[129499, 127997, 8205, 9792, 65039], + &[129499, 127997, 8205, 9794, 65039], + &[129499, 127998, 8205, 9792, 65039], + &[129499, 127998, 8205, 9794, 65039], + &[129499, 127999, 8205, 9792, 65039], + &[129499, 127999, 8205, 9794, 65039], + &[129500, 8205, 9792, 65039], + &[129500, 8205, 9794, 65039], + &[129500, 127995, 8205, 9792, 65039], + &[129500, 127995, 8205, 9794, 65039], + &[129500, 127996, 8205, 9792, 65039], + &[129500, 127996, 8205, 9794, 65039], + &[129500, 127997, 8205, 9792, 65039], + &[129500, 127997, 8205, 9794, 65039], + &[129500, 127998, 8205, 9792, 65039], + &[129500, 127998, 8205, 9794, 65039], + &[129500, 127999, 8205, 9792, 65039], + &[129500, 127999, 8205, 9794, 65039], + &[129501, 8205, 9792, 65039], + &[129501, 8205, 9794, 65039], + &[129501, 127995, 8205, 9792, 65039], + &[129501, 127995, 8205, 9794, 65039], + &[129501, 127996, 8205, 9792, 65039], + &[129501, 127996, 8205, 9794, 65039], + &[129501, 127997, 8205, 9792, 65039], + &[129501, 127997, 8205, 9794, 65039], + &[129501, 127998, 8205, 9792, 65039], + &[129501, 127998, 8205, 9794, 65039], + &[129501, 127999, 8205, 9792, 65039], + &[129501, 127999, 8205, 9794, 65039], + &[129502, 8205, 9792, 65039], + &[129502, 8205, 9794, 65039], + &[129503, 8205, 9792, 65039], + &[129503, 8205, 9794, 65039], + &[128104, 8205, 129456], + &[128104, 8205, 129457], + &[128104, 8205, 129458], + &[128104, 8205, 129459], + &[128104, 127995, 8205, 129456], + &[128104, 127995, 8205, 129457], + &[128104, 127995, 8205, 129458], + &[128104, 127995, 8205, 129459], + &[128104, 127996, 8205, 129456], + &[128104, 127996, 8205, 129457], + &[128104, 127996, 8205, 129458], + &[128104, 127996, 8205, 129459], + &[128104, 127997, 8205, 129456], + &[128104, 127997, 8205, 129457], + &[128104, 127997, 8205, 129458], + &[128104, 127997, 8205, 129459], + &[128104, 127998, 8205, 129456], + &[128104, 127998, 8205, 129457], + &[128104, 127998, 8205, 129458], + &[128104, 127998, 8205, 129459], + &[128104, 127999, 8205, 129456], + &[128104, 127999, 8205, 129457], + &[128104, 127999, 8205, 129458], + &[128104, 127999, 8205, 129459], + &[128105, 8205, 129456], + &[128105, 8205, 129457], + &[128105, 8205, 129458], + &[128105, 8205, 129459], + &[128105, 127995, 8205, 129456], + &[128105, 127995, 8205, 129457], + &[128105, 127995, 8205, 129458], + &[128105, 127995, 8205, 129459], + &[128105, 127996, 8205, 129456], + &[128105, 127996, 8205, 129457], + &[128105, 127996, 8205, 129458], + &[128105, 127996, 8205, 129459], + &[128105, 127997, 8205, 129456], + &[128105, 127997, 8205, 129457], + &[128105, 127997, 8205, 129458], + &[128105, 127997, 8205, 129459], + &[128105, 127998, 8205, 129456], + &[128105, 127998, 8205, 129457], + &[128105, 127998, 8205, 129458], + &[128105, 127998, 8205, 129459], + &[128105, 127999, 8205, 129456], + &[128105, 127999, 8205, 129457], + &[128105, 127999, 8205, 129458], + &[128105, 127999, 8205, 129459], + &[129489, 8205, 129456], + &[129489, 8205, 129457], + &[129489, 8205, 129458], + &[129489, 8205, 129459], + &[129489, 127995, 8205, 129456], + &[129489, 127995, 8205, 129457], + &[129489, 127995, 8205, 129458], + &[129489, 127995, 8205, 129459], + &[129489, 127996, 8205, 129456], + &[129489, 127996, 8205, 129457], + &[129489, 127996, 8205, 129458], + &[129489, 127996, 8205, 129459], + &[129489, 127997, 8205, 129456], + &[129489, 127997, 8205, 129457], + &[129489, 127997, 8205, 129458], + &[129489, 127997, 8205, 129459], + &[129489, 127998, 8205, 129456], + &[129489, 127998, 8205, 129457], + &[129489, 127998, 8205, 129458], + &[129489, 127998, 8205, 129459], + &[129489, 127999, 8205, 129456], + &[129489, 127999, 8205, 129457], + &[129489, 127999, 8205, 129458], + &[129489, 127999, 8205, 129459], + &[9939, 65039, 8205, 128165], + &[10084, 65039, 8205, 128293], + &[10084, 65039, 8205, 129657], + &[127812, 8205, 129003], + &[127819, 8205, 129001], + &[127987, 65039, 8205, 9895, 65039], + &[127987, 65039, 8205, 127752], + &[127988, 8205, 9760, 65039], + &[128008, 8205, 11035], + &[128021, 8205, 129466], + &[128038, 8205, 11035], + &[128038, 8205, 128293], + &[128059, 8205, 10052, 65039], + &[128065, 65039, 8205, 128488, 65039], + &[128558, 8205, 128168], + &[128565, 8205, 128171], + &[128566, 8205, 127787, 65039], + &[128578, 8205, 8596, 65039], + &[128578, 8205, 8597, 65039], + &[129489, 8205, 129648], + &[129489, 127995, 8205, 128048, 8205, 129489, 127996], + &[129489, 127995, 8205, 128048, 8205, 129489, 127997], + &[129489, 127995, 8205, 128048, 8205, 129489, 127998], + &[129489, 127995, 8205, 128048, 8205, 129489, 127999], + &[129489, 127995, 8205, 129648], + &[129489, 127995, 8205, 129775, 8205, 129489, 127996], + &[129489, 127995, 8205, 129775, 8205, 129489, 127997], + &[129489, 127995, 8205, 129775, 8205, 129489, 127998], + &[129489, 127995, 8205, 129775, 8205, 129489, 127999], + &[129489, 127996, 8205, 128048, 8205, 129489, 127995], + &[129489, 127996, 8205, 128048, 8205, 129489, 127997], + &[129489, 127996, 8205, 128048, 8205, 129489, 127998], + &[129489, 127996, 8205, 128048, 8205, 129489, 127999], + &[129489, 127996, 8205, 129648], + &[129489, 127996, 8205, 129775, 8205, 129489, 127995], + &[129489, 127996, 8205, 129775, 8205, 129489, 127997], + &[129489, 127996, 8205, 129775, 8205, 129489, 127998], + &[129489, 127996, 8205, 129775, 8205, 129489, 127999], + &[129489, 127997, 8205, 128048, 8205, 129489, 127995], + &[129489, 127997, 8205, 128048, 8205, 129489, 127996], + &[129489, 127997, 8205, 128048, 8205, 129489, 127998], + &[129489, 127997, 8205, 128048, 8205, 129489, 127999], + &[129489, 127997, 8205, 129648], + &[129489, 127997, 8205, 129775, 8205, 129489, 127995], + &[129489, 127997, 8205, 129775, 8205, 129489, 127996], + &[129489, 127997, 8205, 129775, 8205, 129489, 127998], + &[129489, 127997, 8205, 129775, 8205, 129489, 127999], + &[129489, 127998, 8205, 128048, 8205, 129489, 127995], + &[129489, 127998, 8205, 128048, 8205, 129489, 127996], + &[129489, 127998, 8205, 128048, 8205, 129489, 127997], + &[129489, 127998, 8205, 128048, 8205, 129489, 127999], + &[129489, 127998, 8205, 129648], + &[129489, 127998, 8205, 129775, 8205, 129489, 127995], + &[129489, 127998, 8205, 129775, 8205, 129489, 127996], + &[129489, 127998, 8205, 129775, 8205, 129489, 127997], + &[129489, 127998, 8205, 129775, 8205, 129489, 127999], + &[129489, 127999, 8205, 128048, 8205, 129489, 127995], + &[129489, 127999, 8205, 128048, 8205, 129489, 127996], + &[129489, 127999, 8205, 128048, 8205, 129489, 127997], + &[129489, 127999, 8205, 128048, 8205, 129489, 127998], + &[129489, 127999, 8205, 129648], + &[129489, 127999, 8205, 129775, 8205, 129489, 127995], + &[129489, 127999, 8205, 129775, 8205, 129489, 127996], + &[129489, 127999, 8205, 129775, 8205, 129489, 127997], + &[129489, 127999, 8205, 129775, 8205, 129489, 127998], +]; + +/// Return the code point ranges of the 'RGI_Emoji' Unicode property. +pub(crate) fn rgi_emoji_sets() -> &'static [&'static [u32]] { + RGI_EMOJI.as_slice() +} + +#[derive(Debug, Clone, Copy)] +pub enum UnicodeStringProperty { + BasicEmoji, + EmojiKeycapSequence, + RGIEmojiFlagSequence, + RGIEmojiModifierSequence, + RGIEmojiTagSequence, + RGIEmojiZWJSequence, + RGIEmoji, +} + +pub(crate) fn string_property_sets(value: &UnicodeStringProperty) -> &'static [&'static [u32]] { + use UnicodeStringProperty::*; + match value { + BasicEmoji => basic_emoji_sets(), + EmojiKeycapSequence => emoji_keycap_sequence_sets(), + RGIEmojiFlagSequence => rgi_emoji_flag_sequence_sets(), + RGIEmojiModifierSequence => rgi_emoji_modifier_sequence_sets(), + RGIEmojiTagSequence => rgi_emoji_tag_sequence_sets(), + RGIEmojiZWJSequence => rgi_emoji_zwj_sequence_sets(), + RGIEmoji => rgi_emoji_sets(), + } +} + +pub fn unicode_string_property_from_str(s: &str) -> Option { + use UnicodeStringProperty::*; + match s { + "Basic_Emoji" => Some(BasicEmoji), + "Emoji_Keycap_Sequence" => Some(EmojiKeycapSequence), + "RGI_Emoji_Flag_Sequence" => Some(RGIEmojiFlagSequence), + "RGI_Emoji_Modifier_Sequence" => Some(RGIEmojiModifierSequence), + "RGI_Emoji_Tag_Sequence" => Some(RGIEmojiTagSequence), + "RGI_Emoji_ZWJ_Sequence" => Some(RGIEmojiZWJSequence), + "RGI_Emoji" => Some(RGIEmoji), + _ => None, + } +} diff --git a/third_party/regress/src/util.rs b/third_party/regress/src/util.rs new file mode 100644 index 00000000..4a7eb2e9 --- /dev/null +++ b/third_party/regress/src/util.rs @@ -0,0 +1,286 @@ +use crate::bytesearch::ByteBitmap; +use crate::codepointset::CODE_POINT_MAX; +use crate::codepointset::Interval; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; +use core::cmp::Ordering; +use core::ops::{Index, IndexMut}; +use core::slice::SliceIndex; + +// A macro which expresses either checked or unchecked reachability, depending on prohibit-unsafe. +macro_rules! rs_unreachable { + () => {{ + if cfg!(feature = "prohibit-unsafe") { + unreachable!(); + } else { + unsafe { core::hint::unreachable_unchecked() } + } + }}; + ($msg:expr) => { + if cfg!(feature = "prohibit-unsafe") { + unreachable!($msg); + } else { + unsafe { core::hint::unreachable_unchecked() } + } + }; +} + +/// A trait which performs bounds checking only in debug mode. +pub trait DebugCheckIndex: Index + IndexMut { + fn iat(&self, index: Idx) -> &Self::Output; + fn mat(&mut self, index: Idx) -> &mut Self::Output; +} + +impl DebugCheckIndex for Vec +where + Idx: SliceIndex<[T]> + Clone, +{ + #[inline(always)] + fn iat(&self, idx: Idx) -> &Self::Output { + debug_assert!(self.get(idx.clone()).is_some(), "Index out of bounds"); + if cfg!(feature = "prohibit-unsafe") { + self.index(idx) + } else { + unsafe { self.get_unchecked(idx) } + } + } + + #[inline(always)] + fn mat(&mut self, idx: Idx) -> &mut Self::Output { + debug_assert!(self.get(idx.clone()).is_some(), "Index out of bounds"); + if cfg!(feature = "prohibit-unsafe") { + self.index_mut(idx) + } else { + unsafe { self.get_unchecked_mut(idx) } + } + } +} + +impl DebugCheckIndex for [T] +where + Idx: SliceIndex<[T]> + Clone, +{ + #[inline(always)] + fn iat(&self, idx: Idx) -> &Self::Output { + debug_assert!(self.get(idx.clone()).is_some(), "Index out of bounds"); + if cfg!(feature = "prohibit-unsafe") { + self.index(idx) + } else { + unsafe { self.get_unchecked(idx) } + } + } + + #[inline(always)] + fn mat(&mut self, idx: Idx) -> &mut Self::Output { + debug_assert!(self.get(idx.clone()).is_some(), "Index out of bounds"); + if cfg!(feature = "prohibit-unsafe") { + self.index_mut(idx) + } else { + unsafe { self.get_unchecked_mut(idx) } + } + } +} + +// Helper function for matching u32s against chars. +// It would be pleasant if you could pattern-match u32s against chars, but Rust does not allow this. +// Convert a u32 to a char, except if the conversion fails, return the largest char. +// Be careful to not use the result of this conversion except to pattern match against literals. +pub fn to_char_sat(c: u32) -> char { + char::from_u32(c).unwrap_or(core::char::MAX) +} + +/// \return the first byte of a UTF-8 encoded code point. +/// We do not use char because we don't want to deal with failing on surrogates. +#[inline(always)] +pub fn utf8_first_byte(cp: u32) -> u8 { + debug_assert!(cp <= CODE_POINT_MAX); + if cp < 0x80 { + // One byte encoding. + cp as u8 + } else if cp < 0x800 { + // Two byte encoding. + ((cp >> 6) & 0x1F) as u8 | 0b1100_0000 + } else if cp < 0x10000 { + // Three byte encoding. + ((cp >> 12) & 0x0F) as u8 | 0b1110_0000 + } else { + // Four byte encoding. + ((cp >> 18) & 0x07) as u8 | 0b1111_0000 + } +} + +/// Add all of the first bytes of a code point interval to a byte bitmap. +pub fn add_utf8_first_bytes_to_bitmap(interval: Interval, bitmap: &mut ByteBitmap) { + // Note this is an inclusive interval. + let Interval { first, last } = interval; + let ranges = [ + (first, last.min(0x7F)), // 1 byte range + (first.max(0x80), last.min(0x7FF)), // 2 byte range + (first.max(0x800), last.min(0xFFFF)), // 3 byte range + (first.max(0x10000), last), // 4 byte range + ]; + for (first, last) in ranges.into_iter() { + if first <= last { + for byte in utf8_first_byte(first)..=utf8_first_byte(last) { + bitmap.set(byte); + } + } + } +} + +pub trait SliceHelp { + type Item; + + /// Given that self is sorted according to f, returns the range of indexes + /// where f indicates equal elements. + fn equal_range_by<'a, F>(&'a self, f: F) -> core::ops::Range + where + F: FnMut(&'a Self::Item) -> Ordering; +} + +impl SliceHelp for [T] { + type Item = T; + fn equal_range_by<'a, F>(&'a self, mut f: F) -> core::ops::Range + where + F: FnMut(&'a Self::Item) -> Ordering, + { + let left = self + .binary_search_by(|v| f(v).then(Ordering::Greater)) + .unwrap_err(); + let right = self[left..] + .binary_search_by(|v| f(v).then(Ordering::Less)) + .unwrap_err() + + left; + left..right + } +} + +// Given a byte \p b, keep its low \p mask bits, and then shift left by \p shift. +const fn mask_shift(b: u8, mask: u8, shift: u8) -> u32 { + let masked = b & ((1 << mask) - 1); + (masked as u32) << (shift as u32) +} + +// Number of significant bits in a utf8 continuation byte. +const UTF8_CONT_SIGBITS: u8 = 6; + +/// \return true if \p b is a UTF8 continutation byte. +#[inline(always)] +pub fn is_utf8_continuation(b: u8) -> bool { + (b & 0b1100_0000) == 0b1000_0000 +} + +// Construct a code point from a list of bytes. +#[inline(always)] +pub fn utf8_w2(b0: u8, b1: u8) -> u32 { + debug_assert!(!is_utf8_continuation(b0) && is_utf8_continuation(b1)); + debug_assert!(b0 >> 5 == 0b110); + mask_shift(b0, 5, UTF8_CONT_SIGBITS) | mask_shift(b1, UTF8_CONT_SIGBITS, 0) +} + +#[inline(always)] +pub fn utf8_w3(b0: u8, b1: u8, b2: u8) -> u32 { + debug_assert!( + !is_utf8_continuation(b0) && is_utf8_continuation(b1) && is_utf8_continuation(b2) + ); + debug_assert!(b0 >> 4 == 0b1110); + mask_shift(b0, 4, 2 * UTF8_CONT_SIGBITS) + | mask_shift(b1, UTF8_CONT_SIGBITS, UTF8_CONT_SIGBITS) + | mask_shift(b2, UTF8_CONT_SIGBITS, 0) +} + +#[inline(always)] +pub fn utf8_w4(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 { + debug_assert!( + !is_utf8_continuation(b0) + && is_utf8_continuation(b1) + && is_utf8_continuation(b2) + && is_utf8_continuation(b3) + ); + debug_assert!(b0 >> 3 == 0b11110); + mask_shift(b0, 3, 3 * UTF8_CONT_SIGBITS) + | mask_shift(b1, UTF8_CONT_SIGBITS, 2 * UTF8_CONT_SIGBITS) + | mask_shift(b2, UTF8_CONT_SIGBITS, UTF8_CONT_SIGBITS) + | mask_shift(b3, UTF8_CONT_SIGBITS, 0) +} + +#[cfg(test)] +mod tests { + use super::{ByteBitmap, Interval, SliceHelp, add_utf8_first_bytes_to_bitmap, utf8_first_byte}; + + #[test] + fn ranges() { + let vals = [0, 1, 2, 3, 4, 4, 4, 7, 8, 9, 9]; + let fast_er = |needle: usize| vals.equal_range_by(|v| v.cmp(&needle)); + let slow_er = |needle: usize| { + let mut left = 0; + while left < vals.len() && vals[left] < needle { + left += 1 + } + let mut right = left; + while right < vals.len() && vals[right] == needle { + right += 1 + } + left..right + }; + + for i in 0..10 { + assert_eq!(fast_er(i), slow_er(i)) + } + } + + #[test] + fn utf8() { + for &cp in &[ + 0x0, + 0x7, + 0xFF, + 0x80, + 0xABC, + 0x7FF, + 0x800, + 0x801, + 0xFFFF, + 0x10000, + 0x10001, + 0x1FFFF, + super::CODE_POINT_MAX - 1, + super::CODE_POINT_MAX, + ] { + use super::{utf8_w2, utf8_w3, utf8_w4}; + let mut buff = [0; 4]; + let s = core::char::from_u32(cp).unwrap().encode_utf8(&mut buff); + let bytes = s.as_bytes(); + assert_eq!(bytes[0], utf8_first_byte(cp)); + + match bytes.len() { + 1 => assert_eq!(bytes[0] as u32, cp), + 2 => assert_eq!(utf8_w2(bytes[0], bytes[1]), cp), + 3 => assert_eq!(utf8_w3(bytes[0], bytes[1], bytes[2]), cp), + 4 => assert_eq!(utf8_w4(bytes[0], bytes[1], bytes[2], bytes[3]), cp), + _ => panic!("Unexpected utf8 sequence length"), + } + } + } + + #[test] + fn test_add_utf8_first_bytes_to_bitmap() { + let locs = [ + 0, 1, 2, 3, 17, 25, 34, 99, 127, 128, 150, 255, 256, 257, 511, 512, 513, 0x7FF, 0x800, + 0x905, 0xA123, 0xFF0F, 0xFFFF, 0x10000, 0x10001, 0x1FFFF, 0x20001, 0x2FFF7, 0x50001, + 0x100000, 0x10FFFE, 0x10FFFF, + ]; + for (idx, &first) in locs.iter().enumerate() { + let mut expected = ByteBitmap::default(); + for &last in locs[idx..].iter() { + assert!(first <= last); + for cp in first..=last { + expected.set(utf8_first_byte(cp)); + } + let mut bitmap = ByteBitmap::default(); + add_utf8_first_bytes_to_bitmap(Interval { first, last }, &mut bitmap); + assert_eq!(bitmap, expected); + } + } + } +}